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.
Attributes
- Since:
4.0.0
- Source:
- Lexer.scala
- Graph
- Supertypes
- Self type
- numeric.type
Members list
Value members
Concrete methods
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 legaldesc.numericDesc.trailingDotAllowed
: determines whether a literal like0.
would be considered legaldesc.numericDesc.realNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal may still be individually parsed with its corresponding parser, regardless of the value of the flagdesc.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 bee
orE
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)
Attributes
- See also:
- Since:
4.0.0
- Note:
alias for
real
- Source:
- Lexer.scala
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+
.
Attributes
- See also:
natural
for a full description of integer configuration- Since:
4.0.0
- Source:
- Lexer.scala
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: is1_000_000
allowed? If this is legal, describes what the break character is, and whether it can appear after a hexadecimal/octal/binary prefixdesc.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 with0
are octal numbers.desc.numericDesc.integerNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal can be individually parsed with its corresponding parser, regardless of the value of the flagdesc.numericDesc.{hexadecimal/octal/binary}Leads
: controls what character must follow a0
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 setoctalLeads
toSet.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.
Attributes
- Since:
4.0.0
- Source:
- Lexer.scala
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 legaldesc.numericDesc.trailingDotAllowed
: determines whether a literal like0.
would be considered legaldesc.numericDesc.realNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal may still be individually parsed with its corresponding parser, regardless of the value of the flagdesc.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 bee
orE
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)
Attributes
- See also:
- Since:
4.0.0
- Source:
- Lexer.scala
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+
.
Attributes
- See also:
unsigned
for a full description of signed integer configuration- Since:
4.0.0
- Note:
alias for
integer
- Source:
- Lexer.scala
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.
Attributes
- Since:
4.0.0
- Source:
- Lexer.scala
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: is1_000_000
allowed? If this is legal, describes what the break character is, and whether it can appear after a hexadecimal/octal/binary prefixdesc.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 with0
are octal numbers.desc.numericDesc.integerNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal can be individually parsed with its corresponding parser, regardless of the value of the flagdesc.numericDesc.{hexadecimal/octal/binary}Leads
: controls what character must follow a0
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 setoctalLeads
toSet.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.
Attributes
- Since:
4.0.0
- Note:
alias for
natural
.- Source:
- Lexer.scala
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.
Attributes
- Since:
4.0.0
- Source:
- Lexer.scala