Out of range warning for as.integer64.character and hex support (#228)

* emit out of range exceptions for as.integer64.character

* save expected warning as string, use strrep() to create giant number

* cleaning up tests, check '0x0'

* parameterized test with more warning cases

* NEWS citations

* missing ')'

* tighten inclusions

* parameterize tests for base-10 too, add a few more

* avoid strlen()

* clarify comment

---------

Co-authored-by: Michael Chirico <chiricom@google.com>

Author: hcirellu

NEWS.md

@@ -53,6 +53,7 @@
 1. Coercion to/from integer64 is expanded greatly (includes #199). Thanks @hcirellu.
    - `as.Date`, `as.POSIXct`, `as.POSXlt`, `as.complex`, and `as.raw` get an `integer64` method.
    - `as.integer64` gets `Date`, `POSIXct`, `POSXlt`, `complex`, `raw`, and `difftime` methods.
+1. `as.integer64.character` now supports hexadecimal (base 16) input when prefixed with "0x" or "-0x", e.g. `as.integer64("0x7FFFFFFFFFFFFFFF")`. Thanks @hcirellu for a PR which completes work begun by @marcpaterno.
 
 ## BUG FIXES
 
@@ -62,6 +63,7 @@
 1. `sortfin(integer64(), 1:10)` no longer segfaults (#164).
 1. `orderfin(as.integer64(10:1), 1:3, 8:11)` enforces that `table` be sorted by `order` instead of segfaulting (#166).
 1. `ordertab()` no longer segfaults when `nunique` is smaller than the actual number of unique values (#168).
+1. `as.integer64.character` now returns `NA` for out of range values, with warning, e.g. `as.integer64("22222222222222222222")`. Thanks @hcirellu.
 
 ## NOTES
 

src/integer64.c

@@ -20,6 +20,7 @@
 #include <math.h> // floor
 #include <stdint.h>
 #include <stdlib.h> // strtoll
+#include <errno.h> // ERANGE
 #include <stdbool.h> // for boolean
 
 #include <R.h>
@@ -154,13 +155,34 @@ SEXP as_integer64_character(SEXP x_, SEXP ret_){
   long long i, n = LENGTH(ret_);
   long long * ret = (long long *) REAL(ret_);
   const char * str;
+  SEXP x_el;
   char * endpointer;
+  Rboolean naflag = FALSE;
+  int base;
   for(i=0; i<n; i++){
-    str = CHAR(STRING_ELT(x_, i)); endpointer = (char *)str; // thanks to Murray Stokely 28.1.2012
-    ret[i] = strtoll(str, &endpointer, 10);
-    if (*endpointer)
+    x_el = STRING_ELT(x_, i);
+    if (x_el == NA_STRING){
       ret[i] = NA_INTEGER64;
+    } else {
+      base = 10; // default
+      str = CHAR(x_el);
+      if ((str[0]=='-' && str[1]=='0' && str[2]=='x') || (str[0]=='0' && str[1]=='x')) {
+        base = 16;
+      }
+      endpointer = (char *)str; // thanks to Murray Stokely 28.1.2012
+      errno = 0;
+      ret[i] = strtoll(str, &endpointer, base);
+      if (errno==ERANGE || *endpointer){
+        ret[i] = NA_INTEGER64;
+        naflag = TRUE;
+      } else if (str==endpointer){
+        ret[i] = NA_INTEGER64; // "" -> NA without warning
+      } else if(ret[i]==NA_INTEGER64){ // i.e., received exact string value of NA_INTEGER64 sentinel
+        naflag = TRUE;
+      }
+    }
   }
+  if (naflag)warning(INTEGER64_NA_COERCION_WARNING);
   return ret_;
 }
 

src/integer64.h

@@ -55,6 +55,7 @@
 #define INTEGER64_NAN_CREATED_WARNING "NaNs produced"
 #define INTEGER64_TODOUBLE_WARNING "integer precision lost while converting to double"
 #define BITSTRING_OVERFLOW_WARNING "bitstrings longer than 64 bytes converted to NA, multibyte-characters not allowed"
+#define INTEGER64_NA_COERCION_WARNING "NAs introduced by coercion to integer64 range"
 
 #define PLUS64(e1,e2,ret,naflag) \
     if (e1 == NA_INTEGER64 || e2 == NA_INTEGER64) \

tests/testthat/test-integer64.R

@@ -139,6 +139,54 @@ test_that("integer64 coercion to/from other types work for R >=4.0.0", {
 
 })
 
+test_that("integer64 coercion from character works for numbers near +/- 2^63", {
+  expect_identical(
+    as.character(as.integer64(c("-9223372036854775807", "-9223372036854775806", "9223372036854775806", "9223372036854775807", ""))),
+    c("-9223372036854775807", "-9223372036854775806", "9223372036854775806", "9223372036854775807", NA)
+  )
+})
+
+test_that("Conversion from hex is supported", {
+  expect_identical(
+    as.integer64(c("0x1", "0xF", "0x7FFFFFFFFFFFFFFF", "-0x1", "-0xF", "-0x7FFFFFFFFFFFFFFF", "0x0")),
+    as.integer64(c(1, 15, "9223372036854775807", -1, -15, "-9223372036854775807", 0))
+  )
+})
+
+with_parameters_test_that(
+  "base-10 edge cases return missing",
+  expect_warning(
+    expect_identical(as.integer64(string), NA_integer64_),
+    "NAs introduced by coercion to integer64 range", fixed=TRUE
+  ),
+  string = c(
+    strrep("9", 63L),
+    "9223372036854775808",
+    "-9223372036854775808",
+    "999x",
+    "-999x",
+    "999 "
+  )
+)
+
+with_parameters_test_that(
+  "hex edge cases return missing",
+  expect_warning(
+    expect_identical(as.integer64(string), NA_integer64_),
+    "NAs introduced by coercion to integer64 range", fixed=TRUE
+  ),
+  string = c(
+    "-0x8000000000000000",
+    "0x8000000000000000",
+    "0x",
+    "-0x",
+    "0xx",
+    " 0x",
+    "0x ",
+    "0x0Z"
+  )
+)
+
 test_that("S3 class basics work", {
   x = as.integer64(1:10)
   expect_s3_class(x, "integer64")