Type Members

1.  sealed abstract class BreakCharDesc extends AnyRef

   This class, and its subtypes, describe how break characters are supported within literals.

   This class, and its subtypes, describe how break characters are supported within literals.

   Since

   4.0.0

2.  final case class EscapeDesc(escBegin: Char, literals: Set[Char], mapping: Map[String, Int], decimalEscape: NumericEscape, hexadecimalEscape: NumericEscape, octalEscape: NumericEscape, binaryEscape: NumericEscape, emptyEscape: Option[Char], gapsSupported: Boolean) extends Product with Serializable

   This class describes the valid escape sequences within character and string literals.

   This class describes the valid escape sequences within character and string literals.

   This allows for the definition of different escape sequences as direct literals, mapping from single or multiple characters to specific values, numeric escape sequences with different bases, as well as supporting zero-width escapes and line continuations via string gaps.

   escBegin

   the character that starts an escape sequence, very often this is '\\'.

   literals

   the characters that can be directly escaped, but still represent themselves, for instance '"', or '\\'.

   mapping

   the possible escape sequences that map to a character other than themselves and the (full UTF-16) character they map to, for instance "n" -> 0xa.

   decimalEscape

   if allowed, the description of how numeric escape sequences work for base 10.

   hexadecimalEscape

   if allowed, the description of how numeric escape sequences work for base 16.

   octalEscape

   if allowed, the description of how numeric escape sequences work for base 8.

   binaryEscape

   if allowed, the description of how numeric escape sequences work for base 2.

   emptyEscape

   if one should exist, the character which has no effect on the string but can be used to disambiguate other escape sequences: in Haskell this would be \&.

   gapsSupported

   specifies whether or not string gaps are supported: this is where whitespace can be injected between two escBegin characters and this will all be ignored in the final string, such that "hello \ \world" is "hello world".

3.  sealed abstract class ExponentDesc extends AnyRef

   This class, and its subtypes, describe how scientific exponent notation can be used within real literals.

   This class, and its subtypes, describe how scientific exponent notation can be used within real literals.

   Since

   4.0.0

4.  final class LexicalDesc extends AnyRef

   This class describes the aggregation of a bunch of different sub-configurations for lexing a specific language.

   This class describes the aggregation of a bunch of different sub-configurations for lexing a specific language.

   Since

   4.0.0

   Note

   Documentation for the parameters is found in the copy or companion apply.

5.  final case class NameDesc(identifierStart: CharPred, identifierLetter: CharPred, operatorStart: CharPred, operatorLetter: CharPred) extends Product with Serializable

   The class describes how name-like things are described lexically.

   The class describes how name-like things are described lexically.

   identifierStart

   what characters may start an identifier?

   identifierLetter

   what characters may continue an identifier?

   operatorStart

   what characters may start a user-defined operator?

   operatorLetter

   what characters may continue a user-defined operator?

   Since

   4.0.0

6.  sealed abstract class NumberOfDigits extends AnyRef

   This class, and its subtypes, describe how many digits a numeric escape sequence is allowed.

   This class, and its subtypes, describe how many digits a numeric escape sequence is allowed.

   Since

   4.0.0

7.  final case class NumericDesc(literalBreakChar: BreakCharDesc, leadingDotAllowed: Boolean, trailingDotAllowed: Boolean, leadingZerosAllowed: Boolean, positiveSign: PlusSignPresence, integerNumbersCanBeHexadecimal: Boolean, integerNumbersCanBeOctal: Boolean, integerNumbersCanBeBinary: Boolean, realNumbersCanBeHexadecimal: Boolean, realNumbersCanBeOctal: Boolean, realNumbersCanBeBinary: Boolean, hexadecimalLeads: Set[Char], octalLeads: Set[Char], binaryLeads: Set[Char], decimalExponentDesc: ExponentDesc, hexadecimalExponentDesc: ExponentDesc, octalExponentDesc: ExponentDesc, binaryExponentDesc: ExponentDesc) extends Product with Serializable

   This class describes how numeric literals, in different bases, should be processed lexically.

   This class describes how numeric literals, in different bases, should be processed lexically.

   literalBreakChar

   describes if breaks can be found within numeric literals.

   leadingDotAllowed

   can a real number omit a leading 0 before the point?

   trailingDotAllowed

   can a real number omit a trailing 0 after the point?

   leadingZerosAllowed

   are extraneous zeros allowed at the start of decimal numbers?

   positiveSign

   describes if positive (+) signs are allowed, compulsory, or illegal.

   integerNumbersCanBeHexadecimal

   is it possible for generic "integer numbers" to be hexadecimal?

   integerNumbersCanBeOctal

   is it possible for generic "integer numbers" to be octal?

   integerNumbersCanBeBinary

   is it possible for generic "integer numbers" to be binary?

   realNumbersCanBeHexadecimal

   is it possible for generic "real numbers" to be hexadecimal?

   realNumbersCanBeOctal

   is it possible for generic "real numbers" to be octal?

   realNumbersCanBeBinary

   is it possible for generic "real numbers" to be binary?

   hexadecimalLeads

   what characters begin a hexadecimal literal following a 0 (may be empty).

   octalLeads

   what characters begin an octal literal following a 0 (may be empty).

   binaryLeads

   what characters begin a binary literal following a 0 (may be empty).

   decimalExponentDesc

   describes how scientific exponent notation should work for decimal literals.

   hexadecimalExponentDesc

   describes how scientific exponent notation should work for hexadecimal literals.

   octalExponentDesc

   describes how scientific exponent notation should work for octal literals.

   binaryExponentDesc

   describes how scientific exponent notation should work for binary literals.

   Since

   4.0.0

8.  sealed abstract class NumericEscape extends AnyRef

   This class, and its subtypes, describe how numeric escape sequences should work for a specific base.

   This class, and its subtypes, describe how numeric escape sequences should work for a specific base.

   Since

   4.0.0

9.  sealed abstract class PlusSignPresence extends AnyRef

   This class, and its subtypes, describe whether or not the plus sign (+) is allowed in a specific position.

   This class, and its subtypes, describe whether or not the plus sign (+) is allowed in a specific position.

   Since

   4.0.0

10.  final case class SpaceDesc(lineCommentStart: String, lineCommentAllowsEOF: Boolean, multiLineCommentStart: String, multiLineCommentEnd: String, multiLineNestedComments: Boolean, space: CharPred, whitespaceIsContextDependent: Boolean) extends Product with Serializable

    This class describes how whitespace should be handled lexically.

    This class describes how whitespace should be handled lexically.

    lineCommentStart

    how do single-line comments start? (empty for no single-line comments)

    lineCommentAllowsEOF

    can a single-line comment be terminated by the end-of-file, or must it ends with a newline

    multiLineCommentStart

    how do multi-line comments start? (empty for no multi-line comments)

    multiLineCommentEnd

    how do multi-line comments end? (empty for no multi-line comments)

    multiLineNestedComments

    can multi-line comments be nested within each other?

    space

    what characters serve as whitespace within the language?

    whitespaceIsContextDependent

    can the definition of whitespace change depending on context? (in Python, say, newlines are valid whitespace within parentheses, but are significant outside of them)

    Since

    4.0.0

11.  final case class SymbolDesc(hardKeywords: Set[String], hardOperators: Set[String], caseSensitive: Boolean) extends Product with Serializable

    This class describes how symbols (textual literals in a BNF) should be processed lexically.

    This class describes how symbols (textual literals in a BNF) should be processed lexically.

    hardKeywords

    what keywords are always treated as keywords within the language.

    hardOperators

    what operators are always treated as reserved operators within the language.

    caseSensitive

    are the keywords case sensitive: when false, IF == if.

    Since

    4.0.0

12.  final case class TextDesc(escapeSequences: EscapeDesc, characterLiteralEnd: Char, stringEnds: Set[(String, String)], multiStringEnds: Set[(String, String)], graphicCharacter: CharPred) extends Product with Serializable

    This class describes how textual literals like strings and characters should be processed lexically.

    This class describes how textual literals like strings and characters should be processed lexically.

    escapeSequences

    the description of how escape sequences in literals.

    characterLiteralEnd

    what character starts and ends a character literal.

    stringEnds

    what sequences may begin and end a string literal.

    multiStringEnds

    what sequences may begin and end a multi-line string literal.

    graphicCharacter

    what characters can be written verbatim into a character or string literal.

    Since

    4.0.0