Allow $-prefixed hexadecimal FP as an alternative to 0x

Since we allow the prefix $ instead of 0x for integer constants, do
the same for floating point.  No suffix support at this time; we may
want to consider if that would be appropriate.

3 files changed, 174 insertions, 1 deletions

diff --git a/float.c b/float.c
index 4db4bd0c..db641800 100644
--- a/float.c
+++ b/float.c
@@ -659,6 +659,8 @@ static int to_float(const char *str, int sign, uint8_t * result,
     } else {
         if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
             ok = ieee_flconvert_hex(str + 2, mant, &exponent);
+	else if (str[0] == '$')
+	    ok = ieee_flconvert_hex(str + 1, mant, &exponent);
         else
             ok = ieee_flconvert(str, mant, &exponent);
 
diff --git a/stdscan.c b/stdscan.c
index 3f74869a..9235b08f 100644
--- a/stdscan.c
+++ b/stdscan.c
@@ -140,7 +140,7 @@ int stdscan(void *private_data, struct tokenval *tv)
 		}
 	    } else if (c == 'H' || c == 'h') {
 		has_h = true;
-	    } else if (c == 'P' || c == 'p') {
+	    } else if (is_hex & (c == 'P' || c == 'p')) {
 		is_float = true;
 		if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-')
 		    stdscan_bufptr++;
diff --git a/test/floatx.asm b/test/floatx.asm
index 50995436..22841e6b 100644
--- a/test/floatx.asm
+++ b/test/floatx.asm
@@ -176,3 +176,174 @@
 	do 0x1.ffffffffffffffffffffffffffffffffp+16383	; Rounds to infinity
 	do Inf			; Infinity
 	do NaN
+
+; 16-bit
+	dw 1.0
+	dw $1.0
+	dw 2.0
+	dw $2.0
+	dw $1.0p+1
+	dw $1.0p-1
+	dw $0.0
+	dw $1.23456789
+	dw $0.123456789
+	dw $0.0000123456789
+	dw $1.23456789p10
+	dw $1.23456789p+10
+	dw $1.23456789p-10
+	dw $0.123456789p10
+	dw $0.123456789p+10
+	dw $0.123456789abcdef0123456789abcdef012345p-10
+	dw $0.0000123456789
+	dw $0.0000123456789p+10
+	dw $0.0000123456789p-10
+	dw $1.0p-25		; Underflow
+	dw $1.0p-24		; Smallest denorm
+	dw $1.ffffffffffffffffffffffffffffp-16	; Rounds to denorm
+	dw $1.0p-15		; Denorm
+	dw $1.ffffffffffffffffffffffffffffp-15	; Rounds to normal
+	dw $1.0p-14		; Smallest non-denorm
+	dw $1.0p+15		; Biggest possible exponent
+	dw $1.ffffffffffffffffffffffffffffp+15	; Rounds to infinity
+	dw Inf			; Infinity
+	dw NaN
+
+; 32-bit
+	dd 1.0
+	dd $1.0
+	dd 2.0
+	dd $2.0
+	dd $1.0p+1
+	dd $1.0p-1
+	dd $0.0
+	dd $1.23456789
+	dd $0.123456789
+	dd $0.0000123456789
+	dd $1.23456789p10
+	dd $1.23456789p+10
+	dd $1.23456789p-10
+	dd $0.123456789p10
+	dd $0.123456789p+10
+	dd $0.123456789abcdef0123456789abcdef012345p-10
+	dd $0.0000123456789
+	dd $0.0000123456789p+10
+	dd $0.0000123456789p-10
+	dd $123456789.0
+	dd $0000123456789.0
+	dd $123456789.0p+0
+	dd $123456789.0p+64
+	dd $1.0p-150		; Underflow
+	dd $1.0p-149		; Smallest denorm
+	dd $1.ffffffffffffffffffffffffffffp-128	; Rounds to denorm
+	dd $1.0p-127		; Denorm
+	dd $1.ffffffffffffffffffffffffffffp-127	; Rounds to normal
+	dd $1.0p-126		; Smallest non-denorm
+	dd $1.0p+127		; Biggest possible exponent
+	dd $1.ffffffffffffffffffffffffffffp+127	; Rounds to infinity
+	dd Inf			; Infinity
+	dd NaN
+
+; 64-bit
+	dq 1.0
+	dq $1.0
+	dq 2.0
+	dq $2.0
+	dq $1.0p+1
+	dq $1.0p-1
+	dq $0.0
+	dq $1.23456789
+	dq $0.123456789
+	dq $0.0000123456789
+	dq $1.23456789p10
+	dq $1.23456789p+10
+	dq $1.23456789p-10
+	dq $0.123456789p10
+	dq $0.123456789p+10
+	dq $0.123456789abcdef0123456789abcdef012345p-10
+	dq $0.0000123456789
+	dq $0.0000123456789p+10
+	dq $0.0000123456789p-10
+	dq $123456789.0
+	dq $0000123456789.0
+	dq $123456789.0p+0
+	dq $123456789.0p+300
+	dq $1.0p-1075		; Underflow
+	dq $1.0p-1074		; Smallest denorm
+	dq $1.ffffffffffffffffffffffffffffp-1024	; Rounds to denorm
+	dq $1.0p-1023		; Denorm
+	dq $1.ffffffffffffffffffffffffffffp-1023	; Rounds to normal
+	dq $1.0p-1022		; Smallest non-denorm
+	dq $1.0p+1023		; Biggest possible exponent
+	dq $1.ffffffffffffffffffffffffffffp+1023	; Rounds to infinity
+	dq Inf			; Infinity
+	dq NaN
+
+; 80-bit
+	dt 1.0
+	dt $1.0
+	dt 2.0
+	dt $2.0
+	dt $1.0p+1
+	dt $1.0p-1
+	dt $0.0
+	dt $1.23456789
+	dt $0.123456789
+	dt $0.0000123456789
+	dt $1.23456789p10
+	dt $1.23456789p+10
+	dt $1.23456789p-10
+	dt $0.123456789p10
+	dt $0.123456789p+10
+	dt $0.123456789abcdef0123456789abcdef012345p-10
+	dt $0.0000123456789
+	dt $0.0000123456789p+10
+	dt $0.0000123456789p-10
+	dt $123456789.0
+	dt $0000123456789.0
+	dt $123456789.0p+0
+	dt $123456789.0p+1024
+	dt $1.0p-16446		; Underflow
+	dt $1.0p-16445		; Smallest denorm
+	dt $1.ffffffffffffffffffffffffffffp-16384	; Rounds to denorm
+	dt $1.0p-16383		; Denorm
+	dt $1.ffffffffffffffffffffffffffffp-16383	; Rounds to normal
+	dt $1.0p-16382		; Smallest non-denorm
+	dt $1.0p+16383		; Biggest possible exponent
+	dt $1.ffffffffffffffffffffffffffffp+16383	; Rounds to infinity
+	dt Inf			; Infinity
+	dt NaN
+
+; 128-bit
+	do 1.0
+	do $1.0
+	do 2.0
+	do $2.0
+	do $1.0p+1
+	do $1.0p-1
+	do $0.0
+	do $1.23456789
+	do $0.123456789
+	do $0.0000123456789
+	do $1.23456789p10
+	do $1.23456789p+10
+	do $1.23456789p-10
+	do $0.123456789p10
+	do $0.123456789p+10
+	do $0.123456789abcdef0123456789abcdef012345p-10
+	do $0.0000123456789
+	do $0.0000123456789p+10
+	do $0.0000123456789p-10
+	do $123456789.0
+	do $0000123456789.0
+	do $123456789.0p+0
+	do $123456789.0p+1024
+	do $1.0p-16495		; Underflow
+	do $1.0p-16494		; Smallest denorm
+	do $1.ffffffffffffffffffffffffffffffffp-16384	; Rounds to denorm
+	do $1.0p-16383		; Denorm
+	do $1.ffffffffffffffffffffffffffffffffp-16383	; Rounds to normal
+	do $1.0p-16382		; Smallest non-denorm
+	do $1.0p+16383		; Biggest possible exponent
+	do $1.ffffffffffffffffffffffffffffffffp+16383	; Rounds to infinity
+	do Inf			; Infinity
+	do NaN