abstract class RuleDSL extends RuleDSLBasics with RuleDSLCombinators with RuleDSLActions
- Alphabetic
- By Inheritance
- RuleDSL
- RuleDSLActions
- RuleDSLCombinators
- RuleDSLBasics
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new RuleDSL()
Type Members
-
sealed
trait
ActionOperator[I <: HList, O <: HList, Ops] extends AnyRef
- Definition Classes
- RuleDSLActions
-
sealed
trait
CharRangeSupport extends AnyRef
- Definition Classes
- RuleDSLBasics
-
sealed
trait
NTimes extends AnyRef
- Definition Classes
- RuleDSLCombinators
-
trait
WithSeparatedBy[I <: HList, O <: HList] extends AnyRef
- Definition Classes
- RuleDSLCombinators
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
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( ... )
- def +(other: String): String
- def ->[B](y: B): (RuleDSL, B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
ANY: Rule0
Matches any character except EOI.
Matches any character except EOI.
- Definition Classes
- RuleDSLBasics
- Annotations
- @compileTimeOnly( ... )
-
def
EOI: Char
Matches the EOI (end-of-input) character.
Matches the EOI (end-of-input) character.
- Definition Classes
- RuleDSLBasics
-
def
MATCH: Rule0
Matches no character (i.e.
Matches no character (i.e. doesn't cause the parser to make any progress) but succeeds always (as a rule).
- Definition Classes
- RuleDSLBasics
-
def
MISMATCH[I <: HList, O <: HList]: Rule[I, O]
A generic Rule that always fails.
A generic Rule that always fails.
- Definition Classes
- RuleDSLBasics
-
def
MISMATCH0: Rule0
A Rule0 that always fails.
A Rule0 that always fails.
- Definition Classes
- RuleDSLBasics
-
def
anyOf(chars: String): Rule0
Matches any single one of the given characters.
Matches any single one of the given characters.
Note: This helper has O(n) runtime with n being the length of the given string. If your string consists only of 7-bit ASCII chars using a pre-allocated CharPredicate will be more efficient.
- Definition Classes
- RuleDSLBasics
- Annotations
- @compileTimeOnly( ... )
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
atomic[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]
Marks a rule as "undividable" from an error reporting perspective.
Marks a rule as "undividable" from an error reporting perspective. The parser will never report errors *inside* of the marked rule. Rather, if the rule mismatches, the error will be reported at the very beginning of the attempted rule match.
- Definition Classes
- RuleDSLCombinators
- Annotations
- @compileTimeOnly( ... )
-
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( ... )
-
implicit
def
ch(c: Char): Rule0
Matches the given single character.
Matches the given single character.
- Definition Classes
- RuleDSLBasics
- Annotations
- @compileTimeOnly( ... )
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
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
value andInt
drop[Int :: String :: HNil]
will drop the top two values, which must be an
underneath aInt
(the string being the top stack element).String
- Definition Classes
- RuleDSLActions
- Annotations
- @compileTimeOnly( ... )
- def ensuring(cond: (RuleDSL) ⇒ Boolean, msg: ⇒ Any): RuleDSL
- def ensuring(cond: (RuleDSL) ⇒ Boolean): RuleDSL
- def ensuring(cond: Boolean, msg: ⇒ Any): RuleDSL
- def ensuring(cond: Boolean): RuleDSL
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
fail(expected: String): Rule0
A rule that always fails and causes the parser to immediately terminate the parsing run.
A rule that always fails and causes the parser to immediately terminate the parsing run. The resulting parse error only has a single trace with a single frame which holds the given error message.
- Definition Classes
- RuleDSLBasics
-
def
failX[I <: HList, O <: HList](expected: String): Rule[I, O]
Fully generic variant of fail.
Fully generic variant of fail.
- Definition Classes
- RuleDSLBasics
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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( ... )
-
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( ... )
-
implicit
def
int2NTimes(i: Int): NTimes
- Definition Classes
- RuleDSLCombinators
- Annotations
- @compileTimeOnly( ... )
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
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.
Note: This helper has O(n) runtime with n being the length of the given string. If your string consists only of 7-bit ASCII chars using a pre-allocated CharPredicate will be more efficient.
- Definition Classes
- RuleDSLBasics
- Annotations
- @compileTimeOnly( ... )
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
oneOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Seq, I, O]): Rule[In, StrictOut] 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( ... )
-
def
optional[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Option, I, O]): Rule[In, OptionalOut]
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( ... )
-
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( ... )
-
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
isUnit
nothing is pushed (i.e.push
with a block/expression evaluating toUnit
is identical torun
) - ifT <: HList
all values of the HList is pushed as individual elements - otherwise a single value of typeT
is pushed.- Definition Classes
- RuleDSLActions
- Annotations
- @compileTimeOnly( ... )
-
def
quiet[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]
Marks a rule as "quiet" from an error reporting perspective.
Marks a rule as "quiet" from an error reporting perspective. Quiet rules only show up in error rule traces if no "unquiet" rules match up to the error location. This marker frequently used for low-level syntax rules (like whitespace or comments) that might be matched essentially everywhere and are therefore not helpful when appearing in the "expected" set of an error report.
- Definition Classes
- RuleDSLCombinators
- Annotations
- @compileTimeOnly( ... )
-
implicit
def
range2NTimes(range: Range): NTimes
- Definition Classes
- RuleDSLCombinators
- Annotations
- @compileTimeOnly( ... )
-
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( ... )
-
implicit
def
rule2WithSeparatedBy[I <: HList, O <: HList](r: Rule[I, O] with Repeated): WithSeparatedBy[I, O]
- Definition Classes
- RuleDSLCombinators
- Annotations
- @compileTimeOnly( ... )
-
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 thearg
evaluates to- a rule (i.e. has type
R <: Rule[_, _]
) the result type ofrun
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. (Note: This feature of
is not yet currently implemented.)run
- any other value the result type of
run
is an always succeedingRule0
.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( ... )
-
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( ... )
-
implicit
def
str(s: String): Rule0
Matches the given string of characters.
Matches the given string of characters.
- Definition Classes
- RuleDSLBasics
- Annotations
- @compileTimeOnly( ... )
-
implicit
def
str2CharRangeSupport(s: String): CharRangeSupport
- Definition Classes
- RuleDSLBasics
- Annotations
- @compileTimeOnly( ... )
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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( ... )
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
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( ... )
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
zeroOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Seq, I, O]): Rule[In, OptionalOut] 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( ... )
- def →[B](y: B): (RuleDSL, B)