gh-45: Add FLT infinities, NaN.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -139,6 +139,8 @@
 
 `FLT` literals MUST NOT begin with the radix point (so `.1` is invalid). A leading `-` MAY prefix a `FLT` literal using the same rules as for integers (the dash is part of the literal and is not an operator).
 
+In addition to binary fixed-point forms, the language also recognizes two special `FLT` literal tokens: `INF` and `NaN`. These tokens are matched case-sensitively and are part of the `FLT` literal class. `INF` denotes IEEE-754 infinity and `NaN` denotes a quiet Not-a-Number. `NaN` MUST NOT be negative; `-INF` (the dash token followed by `INF`) is permitted and denotes negative infinity. When `FLT` values are rendered as source, printed via `PRINT`, or serialized by the interpreter, `INF`, `-INF`, and `NaN` MUST appear exactly as shown. Arithmetic and comparison involving these values follow IEEE-754 semantics.
+
 String literal: a sequence of characters enclosed in either double quotation marks (`"`) or single quotation marks (`'`). A string opened with one delimiter MUST be closed with the same delimiter. Newlines are not permitted inside string literals.
 
 String literals support backslash escape codes. Unknown escape codes (or invalid hexadecimal literals in `\x`/`\u`/`\U`) raise syntax errors at parse time.

src/builtins.c

@@ -143,6 +143,12 @@ static char* int_to_binary_str(int64_t val) {
 // Helper: convert float to binary string
 static char* flt_to_binary_str(double val) {
     char buf[128];
+    if (isnan(val)) {
+        return strdup("NaN");
+    }
+    if (isinf(val)) {
+        return strdup(signbit(val) ? "-INF" : "INF");
+    }
     int is_negative = val < 0;
     if (is_negative) val = -val;
 
@@ -877,7 +883,14 @@ static void ser_expr(JsonBuf* jb, SerCtx* ctx, Interpreter* interp, Expr* expr)
             json_obj_field(jb, &first, "loc");
             ser_loc(jb, expr->line, expr->column);
             json_obj_field(jb, &first, "value");
-            jb_append_fmt(jb, "%.17g", expr->as.flt_value);
+            if (isnan(expr->as.flt_value)) {
+                jb_append_json_string(jb, "NaN");
+            } else if (isinf(expr->as.flt_value)) {
+                if (signbit(expr->as.flt_value)) jb_append_json_string(jb, "-INF");
+                else jb_append_json_string(jb, "INF");
+            } else {
+                jb_append_fmt(jb, "%.17g", expr->as.flt_value);
+            }
             json_obj_field(jb, &first, "literal_type");
             jb_append_json_string(jb, "FLT");
             jb_append_char(jb, '}');
@@ -1410,14 +1423,21 @@ static void ser_value(JsonBuf* jb, SerCtx* ctx, Interpreter* interp, Value v) {
             return;
         }
         case VAL_FLT: {
-            char buf[64];
-            snprintf(buf, sizeof(buf), "%.17g", v.as.f);
             jb_append_char(jb, '{');
             bool first = true;
             json_obj_field(jb, &first, "t");
             jb_append_json_string(jb, "FLT");
             json_obj_field(jb, &first, "v");
-            jb_append_json_string(jb, buf);
+            if (isnan(v.as.f)) {
+                jb_append_json_string(jb, "NaN");
+            } else if (isinf(v.as.f)) {
+                if (signbit(v.as.f)) jb_append_json_string(jb, "-INF");
+                else jb_append_json_string(jb, "INF");
+            } else {
+                char buf[64];
+                snprintf(buf, sizeof(buf), "%.17g", v.as.f);
+                jb_append_json_string(jb, buf);
+            }
             jb_append_char(jb, '}');
             return;
         }
@@ -3739,6 +3759,10 @@ static Value builtin_flt(Interpreter* interp, Value* args, int argc, Expr** arg_
         if (s == NULL || *s == '\0') {
             return value_flt(0.0);
         }
+        // Accept special textual FLT values
+        if (strcmp(s, "INF") == 0) return value_flt(INFINITY);
+        if (strcmp(s, "-INF") == 0) return value_flt(-INFINITY);
+        if (strcmp(s, "NaN") == 0) return value_flt(NAN);
         bool neg = false;
         if (*s == '-') {
             neg = true;

src/parser.c

@@ -1,4 +1,5 @@
 #include "parser.h"
+#include <math.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -109,6 +110,32 @@ static bool parse_param_list(Parser* parser, ParamList* params) {
 
 static Expr* parse_primary(Parser* parser) {
     Token token = parser->current_token;
+    // Recognize FLT literal names `INF` and `NaN` as primary expressions
+    if (parser->current_token.type == TOKEN_IDENT) {
+        if (strcmp(parser->current_token.literal, "INF") == 0) {
+            Token t = parser->current_token;
+            advance(parser);
+            return expr_flt(INFINITY, t.line, t.column);
+        }
+        if (strcmp(parser->current_token.literal, "NaN") == 0) {
+            Token t = parser->current_token;
+            advance(parser);
+            return expr_flt(NAN, t.line, t.column);
+        }
+    }
+    // Support negative INF written as `-INF` (but disallow `-NaN`)
+    if (parser->current_token.type == TOKEN_DASH && parser->next_token.type == TOKEN_IDENT) {
+        if (strcmp(parser->next_token.literal, "INF") == 0) {
+            Token dash = parser->current_token;
+            advance(parser); // consume '-'
+            advance(parser); // consume 'INF'
+            return expr_flt(-INFINITY, dash.line, dash.column);
+        }
+        if (strcmp(parser->next_token.literal, "NaN") == 0) {
+            report_error(parser, "NaN must not be negative");
+            return NULL;
+        }
+    }
     if (parser->current_token.type == TOKEN_ASYNC) {
         Token kw = parser->current_token;
         advance(parser);

tests/test2.pre

@@ -27,6 +27,31 @@ DEL(f_quarter)
 DEL(f_threeq)
 PRINT("Floats: PASS\n")
 
+PRINT("Testing INF/NaN literals and conversions...")
+FLT: f_inf = INF
+FLT: f_ninf = -INF
+FLT: f_nan = NaN
+ASSERT(ISFLT(f_inf))
+ASSERT(ISFLT(f_ninf))
+ASSERT(ISFLT(f_nan))
+
+ASSERT(EQ(f_inf, INF))
+ASSERT(EQ(f_ninf, -INF))
+ASSERT(NOT(EQ(f_nan, NaN)))    ! NaN is not equal to itself
+
+TNS: tflts = TFLT(["INF", "-INF", "NaN"])
+ASSERT(ISFLT(tflts[1]))
+ASSERT(ISFLT(tflts[10]))
+ASSERT(ISFLT(tflts[11]))
+ASSERT(EQ(tflts[1], INF))
+ASSERT(EQ(tflts[10], -INF))
+ASSERT(NOT(EQ(tflts[11], NaN)))
+DEL(tflts)
+DEL(f_inf)
+DEL(f_ninf)
+DEL(f_nan)
+PRINT("INF/NaN: PASS\n")
+
 ! String literals
 PRINT("Testing strings...")
 STR: s1 = "Hello, World!"