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" )
  • object lexeme extends Lexeme

    This object is concerned with lexemes: these are tokens that are treated as "words", such that whitespace will be consumed after each has been parsed.

    This object is concerned with lexemes: these are tokens that are treated as "words", such that whitespace will be consumed after each has been parsed.

    Ideally, a wider parser should not be concerned with handling whitespace, as it is responsible for dealing with a stream of tokens. With parser combinators, however, it is usually not the case that there is a separate distinction between the parsing phase and the lexing phase. That said, it is good practice to establish a logical separation between the two worlds. As such, this object contains parsers that parse tokens, and these are whitespace-aware. This means that whitespace will be consumed after any of these parsers are parsed. It is not, however, required that whitespace be present.

    Definition Classes
    Lexer
    Since

    4.0.0

  • enclosing
  • numeric
  • separators
  • text

object numeric

This object contains lexing functionality relevant to the parsing of numbers. This is sub-divided into different categories:

  • integers (both signed and unsigned)
  • reals (signed only)
  • a combination of the two (signed and unsigned)

These contain relevant functionality for the processing of decimal, hexadecimal, octal, and binary literals; or some mixed combination thereof (as specified by desc.numericDesc). Additionally, it is possible to ensure literals represent known sizes or precisions.

Source
Lexer.scala
Since

4.0.0

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. numeric
  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. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  8. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  9. def floating: Real

    This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).

    This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).

    These literals consist of a (possibly optional) integer prefix, with at least one of a fractional component (with .) or an exponential component.

    Real numbers are an extension of signed integers with the following additional configuration:

    • desc.numericDesc.leadingDotAllowed: determines whether a literal like .0 would be considered legal
    • desc.numericDesc.trailingDotAllowed: determines whether a literal like 0. would be considered legal
    • desc.numericDesc.realNumbersCanBe{Hexadecimal/Octal/Binary}: these flags control what kind of literals can appear within the number parser. Each type of literal may still be individually parsed with its corresponding parser, regardless of the value of the flag
    • desc.numericDesc.{decimal/hexadecimal/octal/binary}ExponentDesc: describes how the exponential syntax works for each kind of base. If the syntax is legal, then this describes: which characters start it (classically, this would be e or E for decimals); whether or not it is compulsory for the literal (in Java and C, hexadecimal floats are only valid when they have an exponent attached); and whether or not a + sign is mandatory, optional, or illegal for positive exponents

    Additional to the parsing of decimal, hexadecimal, octal, and binary floating literals, each parser can be given a precision of IEEE 754 float or double. This can either be achieved by rounding to the nearest representable value, or by ensuring that the literal must be precisely representable as one of these numbers (which is defined as being one of binary, decimal or exact float and double values as described by Java)

    Since

    4.0.0

    Note

    alias for real

    See also

    natural and integer for a full description of the configuration for the start of a real number

  10. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. val integer: Integer

    This is a collection of parsers concerned with handling signed integer literals.

    This is a collection of parsers concerned with handling signed integer literals.

    Signed integer literals are an extension of unsigned integer literals with the following extra configuration:

    • desc.numericDesc.positiveSign: describes whether or not literals are allowed to omit + for positive literals, must write a +, or can never write a +.
    Since

    4.0.0

    See also

    natural for a full description of integer configuration

  13. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  14. val natural: Integer

    This is a collection of parsers concerned with handling unsigned (positive) integer literals.

    This is a collection of parsers concerned with handling unsigned (positive) integer literals.

    Natural numbers are described generally as follows:

    • desc.numericDesc.literalBreakChar: determines whether or not it is legal to "break up" the digits within a literal, for example: is 1_000_000 allowed? If this is legal, describes what the break character is, and whether it can appear after a hexadecimal/octal/binary prefix
    • desc.numericDesc.leadingZerosAllowed: determines whether or not it is possible to add extraneous zero digits onto the front of a number or not. In some languages, like C, this is disallowed, as numbers starting with 0 are octal numbers.
    • desc.numericDesc.integerNumbersCanBe{Hexadecimal/Octal/Binary}: these flags control what kind of literals can appear within the number parser. Each type of literal can be individually parsed with its corresponding parser, regardless of the value of the flag
    • desc.numericDesc.{hexadecimal/octal/binary}Leads: controls what character must follow a 0 when starting a number to change it from decimal into another base. This set may be empty, in which case the literal is described purely with leading zero (C style octals would set octalLeads to Set.empty)

    Additional to the parsing of decimal, hexadecimal, octal, and binary literals, each parser can be given a bit-width from 8- to 64-bit: this will check the parsed literal to ensure it is a legal literal of that size.

    Since

    4.0.0

  15. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  17. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  18. val real: Real

    This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).

    This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).

    These literals consist of a (possibly optional) integer prefix, with at least one of a fractional component (with .) or an exponential component.

    Real numbers are an extension of signed integers with the following additional configuration:

    • desc.numericDesc.leadingDotAllowed: determines whether a literal like .0 would be considered legal
    • desc.numericDesc.trailingDotAllowed: determines whether a literal like 0. would be considered legal
    • desc.numericDesc.realNumbersCanBe{Hexadecimal/Octal/Binary}: these flags control what kind of literals can appear within the number parser. Each type of literal may still be individually parsed with its corresponding parser, regardless of the value of the flag
    • desc.numericDesc.{decimal/hexadecimal/octal/binary}ExponentDesc: describes how the exponential syntax works for each kind of base. If the syntax is legal, then this describes: which characters start it (classically, this would be e or E for decimals); whether or not it is compulsory for the literal (in Java and C, hexadecimal floats are only valid when they have an exponent attached); and whether or not a + sign is mandatory, optional, or illegal for positive exponents

    Additional to the parsing of decimal, hexadecimal, octal, and binary floating literals, each parser can be given a precision of IEEE 754 float or double. This can either be achieved by rounding to the nearest representable value, or by ensuring that the literal must be precisely representable as one of these numbers (which is defined as being one of binary, decimal or exact float and double values as described by Java)

    Since

    4.0.0

    See also

    natural and integer for a full description of the configuration for the start of a real number

  19. def signed: Integer

    This is a collection of parsers concerned with handling signed integer literals.

    This is a collection of parsers concerned with handling signed integer literals.

    Signed integer literals are an extension of unsigned integer literals with the following extra configuration:

    • desc.numericDesc.positiveSign: describes whether or not literals are allowed to omit + for positive literals, must write a +, or can never write a +.
    Since

    4.0.0

    Note

    alias for integer

    See also

    unsigned for a full description of signed integer configuration

  20. val signedCombined: Combined

    This is a collection of parsers concerned with handling numeric literals that may either be signed integers or signed reals.

    This is a collection of parsers concerned with handling numeric literals that may either be signed integers or signed reals.

    There is no additional configuration offered over that found in integer or real.

    the bit-bounds and precision of the integer or real parts of the result can be specified in any pairing.

    Since

    4.0.0

  21. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  22. def toString(): String
    Definition Classes
    AnyRef → Any
  23. def unsigned: Integer

    This is a collection of parsers concerned with handling unsigned (positive) integer literals.

    This is a collection of parsers concerned with handling unsigned (positive) integer literals.

    Natural numbers are described generally as follows:

    • desc.numericDesc.literalBreakChar: determines whether or not it is legal to "break up" the digits within a literal, for example: is 1_000_000 allowed? If this is legal, describes what the break character is, and whether it can appear after a hexadecimal/octal/binary prefix
    • desc.numericDesc.leadingZerosAllowed: determines whether or not it is possible to add extraneous zero digits onto the front of a number or not. In some languages, like C, this is disallowed, as numbers starting with 0 are octal numbers.
    • desc.numericDesc.integerNumbersCanBe{Hexadecimal/Octal/Binary}: these flags control what kind of literals can appear within the number parser. Each type of literal can be individually parsed with its corresponding parser, regardless of the value of the flag
    • desc.numericDesc.{hexadecimal/octal/binary}Leads: controls what character must follow a 0 when starting a number to change it from decimal into another base. This set may be empty, in which case the literal is described purely with leading zero (C style octals would set octalLeads to Set.empty)

    Additional to the parsing of decimal, hexadecimal, octal, and binary literals, each parser can be given a bit-width from 8- to 64-bit: this will check the parsed literal to ensure it is a legal literal of that size.

    Since

    4.0.0

    Note

    alias for natural.

  24. val unsignedCombined: Combined

    This is a collection of parsers concerned with handling numeric literals that may either be unsigned integers or unsigned reals.

    This is a collection of parsers concerned with handling numeric literals that may either be unsigned integers or unsigned reals.

    There is no additional configuration offered over that found in natural or real.

    the bit-bounds and precision of the integer or real parts of the result can be specified in any pairing.

    Since

    4.0.0

  25. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  26. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  27. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped