Module ch.randelshofer.fastdoubleparser

Package ch.randelshofer.fastdoubleparser

Class AbstractJavaFloatingPointBitsFromCharArray

java.lang.Object

ch.randelshofer.fastdoubleparser.AbstractNumberParser

ch.randelshofer.fastdoubleparser.AbstractFloatValueParser

ch.randelshofer.fastdoubleparser.AbstractJavaFloatingPointBitsFromCharArray

Direct Known Subclasses:

JavaDoubleBitsFromCharArray, JavaFloatBitsFromCharArray

abstract class AbstractJavaFloatingPointBitsFromCharArray
extends AbstractFloatValueParser

Parses a Java FloatingPointLiteral from a char array.

This class should have a type parameter for the return value of its parse methods. Unfortunately Java does not support type parameters for primitive types. As a workaround we use long. A long has enough bits to fit a double value or a float value.

See JavaDoubleParser for the grammar of FloatingPointLiteral.

Field Summary

Fields

Modifier and Type	Field	Description
private static boolean	CONDITIONAL_COMPILATION_PARSE_EIGHT_HEX_DIGITS

Fields inherited from class ch.randelshofer.fastdoubleparser.AbstractFloatValueParser

MAX_EXPONENT_NUMBER, MAX_INPUT_LENGTH, MINIMAL_NINETEEN_DIGIT_INTEGER

Fields inherited from class ch.randelshofer.fastdoubleparser.AbstractNumberParser

CHAR_TO_HEX_MAP, DECIMAL_POINT_CLASS, ILLEGAL_OFFSET_OR_ILLEGAL_LENGTH, OTHER_CLASS, SYNTAX_ERROR, SYNTAX_ERROR_BITS, VALUE_EXCEEDS_LIMITS

Constructor Summary

Constructors

Constructor	Description
AbstractJavaFloatingPointBitsFromCharArray()

Method Summary

Modifier and Type	Method	Description
(package private) abstract long	nan()
(package private) abstract long	negativeInfinity()
private long	parseDecFloatLiteral(char[] str, int index, int startIndex, int endIndex, boolean isNegative)	Parses a DecimalFloatingPointLiteral production with optional trailing white space until the end of the text.
long	parseFloatingPointLiteral(char[] str, int offset, int length)	Parses a FloatingPointLiteral production with optional leading and trailing white space.
private long	parseHexFloatLiteral(char[] str, int index, int startIndex, int endIndex, boolean isNegative)	Parses the following rules (more rules are defined in AbstractFloatValueParser): RestOfHexFloatingPointLiteral: RestOfHexSignificand BinaryExponent RestOfHexSignificand: HexDigits HexDigits . [HexDigits] . HexDigits
private long	parseNaNOrInfinity(char[] str, int index, int endIndex, boolean isNegative)
(package private) abstract long	positiveInfinity()
private static int	skipWhitespace(char[] str, int index, int endIndex)	Skips optional white space in the provided string
private long	tryToParseEightHexDigits(char[] str, int offset)
(package private) abstract long	valueOfFloatLiteral(char[] str, int startIndex, int endIndex, boolean isNegative, long significand, int exponent, boolean isSignificandTruncated, int exponentOfTruncatedSignificand)	Computes a float value from the given components of a decimal float literal.
(package private) abstract long	valueOfHexLiteral(char[] str, int startIndex, int endIndex, boolean isNegative, long significand, int exponent, boolean isSignificandTruncated, int exponentOfTruncatedSignificand)	Computes a float value from the given components of a hexadecimal float literal.

Methods inherited from class ch.randelshofer.fastdoubleparser.AbstractNumberParser

charAt, charAt, charAt, checkBounds, checkBounds, lookupHex, lookupHex

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

CONDITIONAL_COMPILATION_PARSE_EIGHT_HEX_DIGITS

private static final boolean CONDITIONAL_COMPILATION_PARSE_EIGHT_HEX_DIGITS

See Also:

Constant Field Values

Constructor Detail

AbstractJavaFloatingPointBitsFromCharArray

AbstractJavaFloatingPointBitsFromCharArray()

Method Detail

skipWhitespace

private static int skipWhitespace(char[] str,
                                  int index,
                                  int endIndex)

Skips optional white space in the provided string

Parameters:

str - a string

index - start index (inclusive) of the optional white space

endIndex - end index (exclusive) of the optional white space

Returns:

index after the optional white space

nan

abstract long nan()

Returns:

a NaN constant in the specialized type wrapped in a long

negativeInfinity

abstract long negativeInfinity()

Returns:

a negative infinity constant in the specialized type wrapped in a long

parseDecFloatLiteral

private long parseDecFloatLiteral(char[] str,
                                  int index,
                                  int startIndex,
                                  int endIndex,
                                  boolean isNegative)

Parses a DecimalFloatingPointLiteral production with optional trailing white space until the end of the text. Given that we have already consumed the optional leading zero of the DecSignificand.

DecimalFloatingPointLiteralWithWhiteSpace:

DecimalFloatingPointLiteral [WhiteSpace] EOT

See JavaDoubleParser for the grammar of DecimalFloatingPointLiteral and DecSignificand.

Parameters:

str - a string

index - the current index

startIndex - start index inclusive of the DecimalFloatingPointLiteralWithWhiteSpace

endIndex - end index (exclusive)

isNegative - true if the float value is negative

Returns:

the bit pattern of the parsed value, if the input is legal; otherwise, -1L.

parseFloatingPointLiteral

public long parseFloatingPointLiteral(char[] str,
                                      int offset,
                                      int length)

Parses a FloatingPointLiteral production with optional leading and trailing white space.

FloatingPointLiteralWithWhiteSpace:

[WhiteSpace] FloatingPointLiteral [WhiteSpace]

See JavaDoubleParser for the grammar of FloatingPointLiteral.

Parameters:

str - a string containing a FloatingPointLiteralWithWhiteSpace

offset - start offset of FloatingPointLiteralWithWhiteSpace in str

length - length of FloatingPointLiteralWithWhiteSpace in str

Returns:

the bit pattern of the parsed value, if the input is legal; otherwise, -1L.

parseHexFloatLiteral

private long parseHexFloatLiteral(char[] str,
                                  int index,
                                  int startIndex,
                                  int endIndex,
                                  boolean isNegative)

Parses the following rules (more rules are defined in AbstractFloatValueParser):

RestOfHexFloatingPointLiteral:

RestOfHexSignificand BinaryExponent

RestOfHexSignificand:

HexDigits

HexDigits .

[HexDigits] . HexDigits

Parameters:

str - the input string

index - index to the first character of RestOfHexFloatingPointLiteral

startIndex - the start index of the string

endIndex - the end index of the string

isNegative - if the resulting number is negative

Returns:

the bit pattern of the parsed value, if the input is legal; otherwise, -1L.

parseNaNOrInfinity

private long parseNaNOrInfinity(char[] str,
                                int index,
                                int endIndex,
                                boolean isNegative)

positiveInfinity

abstract long positiveInfinity()

Returns:

a positive infinity constant in the specialized type wrapped in a long

tryToParseEightHexDigits

private long tryToParseEightHexDigits(char[] str,
                                      int offset)

valueOfFloatLiteral

abstract long valueOfFloatLiteral(char[] str,
                                  int startIndex,
                                  int endIndex,
                                  boolean isNegative,
                                  long significand,
                                  int exponent,
                                  boolean isSignificandTruncated,
                                  int exponentOfTruncatedSignificand)

Computes a float value from the given components of a decimal float literal.

Parameters:

str - the string that contains the float literal (and maybe more)

startIndex - the start index (inclusive) of the float literal inside the string

endIndex - the end index (exclusive) of the float literal inside the string

isNegative - whether the float value is negative

significand - the significand of the float value (can be truncated)

exponent - the exponent of the float value

isSignificandTruncated - whether the significand is truncated

exponentOfTruncatedSignificand - the exponent value of the truncated significand

Returns:

the bit pattern of the parsed value, if the input is legal; otherwise, -1L.

valueOfHexLiteral

abstract long valueOfHexLiteral(char[] str,
                                int startIndex,
                                int endIndex,
                                boolean isNegative,
                                long significand,
                                int exponent,
                                boolean isSignificandTruncated,
                                int exponentOfTruncatedSignificand)

Computes a float value from the given components of a hexadecimal float literal.

Parameters:

str - the string that contains the float literal (and maybe more)

startIndex - the start index (inclusive) of the float literal inside the string

endIndex - the end index (exclusive) of the float literal inside the string

isNegative - whether the float value is negative

significand - the significand of the float value (can be truncated)

exponent - the exponent of the float value

isSignificandTruncated - whether the significand is truncated

exponentOfTruncatedSignificand - the exponent value of the truncated significand

Returns:

the bit pattern of the parsed value, if the input is legal; otherwise, -1L.