Packages

  • package root
    Definition Classes
    root
  • package parsley
    Definition Classes
    root
  • package token

    This package provides a wealth of functionality for performing common lexing tasks.

    This package provides a wealth of functionality for performing common lexing tasks.

    It is organised as follows:

    • the main parsing functionality is accessed via Lexer, which provides implementations for the combinators found in the sub-packages given a LexicalDesc.
    • the descriptions sub-package is how a lexical structure can be described, providing the configuration that alters the behaviour of the parsers produced by the Lexer.
    • the other sub-packages contain the high-level interfaces that the Lexer exposes, which can be used to pass whitespace-aware and non-whitespace-aware combinators around in a uniform way.
    • the predicate module contains functionality to help define boolean predicates on characters or unicode codepoints.
    Definition Classes
    parsley
  • class Lexer extends AnyRef

    This class provides a large selection of functionality concerned with lexing.

    This class provides a large selection of functionality concerned with lexing.

    This class provides lexing functionality to parsley, however it is guaranteed that nothing in this class is not implementable purely using parsley's pre-existing functionality. These are regular parsers, but constructed in such a way that they create a clear and logical separation from the rest of the parser.

    The class is broken up into several internal "modules" that group together similar kinds of functionality. Importantly, the lexemes and nonlexemes objects separate the underlying token implementations based on whether or not they consume whitespace or not. Functionality is broadly duplicated across both of these modules: lexemes should be used by a wider parser, to ensure whitespace is handled uniformly; and nonlexemes should be used to define further composite tokens or in special circumstances where whitespace should not be consumed.

    It is possible that some of the implementations of parsers found within this class may have been hand-optimised for performance: care will have been taken to ensure these implementations precisely match the semantics of the originals.

    Definition Classes
    token
    Annotations
    @deprecatedInheritance( ... , "4.1.0" )
  • lexeme
  • nonlexeme
  • space

object space

This object is concerned with special treatment of whitespace.

For the vast majority of cases, the functionality within this object shouldn't be needed, as whitespace is consistently handled by lexeme and fully. However, for grammars where whitespace is significant (like indentation-sensitive languages), this object provides some more fine-grained control over how whitespace is consumed by the parsers within lexeme.

Source
Lexer.scala
Since

4.0.0

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. space
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def alter[A](newSpace: CharPredicate)(within: ⇒ Parsley[A]): Parsley[A]

    This combinator changes how whitespace is parsed by lexemes for the duration of a given parser.

    This combinator changes how whitespace is parsed by lexemes for the duration of a given parser.

    So long as spaceDesc.whiteSpaceIsContextDependent is set to true, this combinator will be able to locally change the definition of whitespace during the given parser.

    newSpace

    the new implementation of whitespace to be used during the execution of within.

    within

    the parser that should be parsed using the updated whitespace.

    Example:

    1. In indentation sensitive languages, the indentation sensitivity is often ignored within parentheses or braces. In these cases lexeme.enclosing.parens(space.alter(withNewline)(p)) would allow unrestricted newlines within parentheses.

    Since

    4.0.0

    Note

    the whitespace will not be restored to its original implementation if the given parser fails having consumed input.

  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. def init: Parsley[Unit]

    This parser initialises the whitespace used by the lexer when spaceDesc.whiteSpaceIsContextDependent is set to true.

    This parser initialises the whitespace used by the lexer when spaceDesc.whiteSpaceIsContextDependent is set to true.

    The whitespace is set to the implementation given by the lexical description. This parser must be used, by fully or otherwise, as the first thing the global parser does or an UnfilledRegisterException will occur.

    Since

    4.0.0

    Note

    this parser is automatically invoked by the fully combinator when applicable.

    See also

    alter for how to change whitespace during a parse.

  13. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  14. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  16. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  17. lazy val skipComments: Parsley[Unit]

    This parser skips zero or more comments.

    This parser skips zero or more comments.

    The implementation of this combinator does not vary with whitespaceIsContextDependent. It will use the hide combinator as to not appear as a valid alternative in an error message: adding a comment is often legal, but not a useful solution for how to make the input syntactically valid.

    Since

    4.0.0

  18. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  19. def toString(): String
    Definition Classes
    AnyRef → Any
  20. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  22. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  23. val whiteSpace: Parsley[Unit]

    This parser skips zero or more (insignificant) whitespace characters as well as comments.

    This parser skips zero or more (insignificant) whitespace characters as well as comments.

    The implementation of this parser depends on whether whitespaceIsContextDependent is set: when it is, this parser may change based on the use of the alter combinator. This parser will always use the hide combinator as to not appear as a valid alternative in an error message: it's likely always the case whitespace can be added at any given time, but that doesn't make it a useful suggestion unless it is significant.

    Since

    4.0.0

Inherited from AnyRef

Inherited from Any

Ungrouped