Add term_to_bigint and term_is_bigint

Replace duplicated code with new functions in term.h.

Signed-off-by: Davide Bettio <davide@uninstall.it>

Author: bettio

src/libAtomVM/bif.c

@@ -79,12 +79,6 @@
     #define INT64_MAX_AS_AVM_FLOAT 9223372036854775295.0 // 0x43DFFFFFFFFFFFFF = 2^62 * 1.1...1b
 #endif
 
-// intn.h and term.h headers are decoupled. We check here that sign enum values are matching.
-_Static_assert(
-    (int) TermPositiveInteger == (int) IntNPositiveInteger, "term/intn definition mismatch");
-_Static_assert(
-    (int) TermNegativeInteger == (int) IntNNegativeInteger, "term/intn definition mismatch");
-
 static term make_bigint(Context *ctx, uint32_t fail_label, uint32_t live,
     const intn_digit_t bigres[], size_t bigres_len, intn_integer_sign_t sign);
 
@@ -842,11 +836,9 @@ static term make_bigint(Context *ctx, uint32_t fail_label, uint32_t live,
 static void conv_term_to_bigint(term arg1, intn_digit_t *tmp_buf1, const intn_digit_t **b1,
     size_t *b1_len, intn_integer_sign_t *b1_sign)
 {
-    if (term_is_boxed_integer(arg1)
-        && (term_boxed_size(arg1) > (INTN_INT64_LEN * sizeof(intn_digit_t)) / sizeof(term))) {
-        *b1 = term_intn_data(arg1);
-        *b1_len = term_intn_size(arg1) * (sizeof(term) / sizeof(intn_digit_t));
-        *b1_sign = (intn_integer_sign_t) term_boxed_integer_sign(arg1);
+    if (term_is_bigint(arg1)) {
+        term_to_bigint(arg1, b1, b1_len, b1_sign);
+
     } else {
         avm_int64_t i64 = term_maybe_unbox_int64(arg1);
         intn_from_int64(i64, tmp_buf1, b1_sign);
@@ -1146,10 +1138,10 @@ term bif_erlang_div_2(Context *ctx, uint32_t fail_label, int live, term arg1, te
 // that just copies the given term but changes the sign
 static term neg_bigint(Context *ctx, uint32_t fail_label, uint32_t live, term arg1)
 {
-    // update when updating conv_term_to_bigint
-    intn_digit_t *m = term_intn_data(arg1);
-    size_t m_len = term_intn_size(arg1) * (sizeof(term) / sizeof(intn_digit_t));
-    intn_integer_sign_t m_sign = (intn_integer_sign_t) term_boxed_integer_sign(arg1);
+    const intn_digit_t *m;
+    size_t m_len;
+    intn_integer_sign_t m_sign;
+    term_to_bigint(arg1, &m, &m_len, &m_sign);
 
     intn_digit_t tmp_copy[INTN_MAX_RES_LEN];
     memcpy(tmp_copy, m, m_len * sizeof(intn_digit_t));
@@ -1242,9 +1234,10 @@ term bif_erlang_neg_1(Context *ctx, uint32_t fail_label, int live, term arg1)
 // that just copies the given term but changes the sign
 static term abs_bigint(Context *ctx, uint32_t fail_label, uint32_t live, term arg1)
 {
-    // update when updating conv_term_to_bigint
-    intn_digit_t *m = term_intn_data(arg1);
-    size_t m_len = term_intn_size(arg1) * (sizeof(term) / sizeof(intn_digit_t));
+    const intn_digit_t *m;
+    size_t m_len;
+    intn_integer_sign_t discarded_sign;
+    term_to_bigint(arg1, &m, &m_len, &discarded_sign);
 
     intn_digit_t tmp_copy[INTN_MAX_RES_LEN];
     memcpy(tmp_copy, m, m_len * sizeof(intn_digit_t));

src/libAtomVM/externalterm.c

@@ -234,14 +234,12 @@ static int serialize_term(uint8_t *buf, term t, GlobalContext *glb)
                 return SMALL_BIG_EXT_BASE_SIZE + num_bytes;
             }
         } else {
-            size_t intn_size = term_intn_size(t);
-            size_t digits_per_term = sizeof(term) / sizeof(intn_digit_t);
-            size_t bigint_len = intn_size * digits_per_term;
-            const intn_digit_t *bigint = (const intn_digit_t *) term_intn_data(t);
+            const intn_digit_t *bigint;
+            size_t bigint_len;
+            intn_integer_sign_t sign;
+            term_to_bigint(t, &bigint, &bigint_len, &sign);
             size_t num_bytes = intn_required_unsigned_integer_bytes(bigint, bigint_len);
             if (buf != NULL) {
-                intn_integer_sign_t sign = (intn_integer_sign_t) term_boxed_integer_sign(t);
-
                 buf[0] = SMALL_BIG_EXT;
                 buf[1] = num_bytes;
                 buf[2] = sign == IntNNegativeInteger ? 0x01 : 0x00;

src/libAtomVM/nifs.c

@@ -2396,12 +2396,11 @@ static term integer_to_buf(Context *ctx, int argc, term argv[], char *tmp_buf, s
             }
 #endif
             default: {
-                size_t boxed_size = term_intn_size(value);
-                size_t digits_per_term = sizeof(term) / sizeof(intn_digit_t);
-                const intn_digit_t *intn_buf = (const intn_digit_t *) term_intn_data(value);
-                intn_integer_sign_t sign = (intn_integer_sign_t) term_boxed_integer_sign(value);
-                *int_buf
-                    = intn_to_string(intn_buf, boxed_size * digits_per_term, sign, base, int_len);
+                const intn_digit_t *intn_buf;
+                size_t intn_buf_len;
+                intn_integer_sign_t sign;
+                term_to_bigint(value, &intn_buf, &intn_buf_len, &sign);
+                *int_buf = intn_to_string(intn_buf, intn_buf_len, sign, base, int_len);
                 *needs_cleanup = true;
             }
         }

src/libAtomVM/term.c

@@ -420,13 +420,12 @@ int term_funprint(PrinterFun *fun, term t, const GlobalContext *global)
                 return fun->print(fun, AVM_INT64_FMT, term_unbox_int64(t));
 #endif
             default: {
-                size_t digits_per_term = sizeof(term) / sizeof(intn_digit_t);
-                size_t boxed_size = term_intn_size(t);
-                const intn_digit_t *intn_data = (const intn_digit_t *) term_intn_data(t);
-                intn_integer_sign_t sign = (intn_integer_sign_t) term_boxed_integer_sign(t);
+                const intn_digit_t *intn_data;
+                size_t intn_data_len;
+                intn_integer_sign_t sign;
+                term_to_bigint(t, &intn_data, &intn_data_len, &sign);
                 size_t unused_s_len;
-                char *s = intn_to_string(
-                    intn_data, boxed_size * digits_per_term, sign, 10, &unused_s_len);
+                char *s = intn_to_string(intn_data, intn_data_len, sign, 10, &unused_s_len);
                 if (IS_NULL_PTR(s)) {
                     return -1;
                 }
@@ -1087,12 +1086,12 @@ avm_float_t term_conv_to_float(term t)
                 return term_unbox_int64(t);
 #endif
             default: {
-                const intn_digit_t *num = (intn_digit_t *) term_intn_data(t);
-                size_t digits_per_term = (sizeof(term) / sizeof(intn_digit_t));
-                size_t len = boxed_size * digits_per_term;
-                term_integer_sign_t t_sign = term_boxed_integer_sign(t);
+                const intn_digit_t *num;
+                size_t num_len;
+                intn_integer_sign_t num_sign;
+                term_to_bigint(t, &num, &num_len, &num_sign);
 
-                return intn_to_double(num, len, (intn_integer_sign_t) t_sign);
+                return intn_to_double(num, num_len, num_sign);
             }
         }
     } else {

src/libAtomVM/term.h

@@ -1315,12 +1315,6 @@ static inline void *term_intn_data(term t)
     return (void *) (boxed_value + 1);
 }
 
-static inline size_t term_intn_size(term t)
-{
-    const term *boxed_value = term_to_const_term_ptr(t);
-    return term_get_size_from_boxed_header(boxed_value[0]);
-}
-
 static inline void term_intn_to_term_size(size_t n, size_t *intn_data_size, size_t *rounded_num_len)
 {
     size_t bytes = n * sizeof(intn_digit_t);
@@ -1340,6 +1334,85 @@ static inline void term_intn_to_term_size(size_t n, size_t *intn_data_size, size
     *rounded_num_len = rounded / sizeof(intn_digit_t);
 }
 
+/**
+ * @brief Check if term is a multi-precision integer larger than \c int64_t
+ *
+ * Tests whether a term represents a boxed integer that requires multi-precision
+ * representation (i.e., larger than can fit in \c int64_t). These are integers
+ * that need more than \c INTN_INT64_LEN digits for their representation.
+ *
+ * In the current implementation, a bigint is defined as a boxed integer with
+ * size greater than:
+ * - \c BOXED_TERMS_REQUIRED_FOR_INT64 on 32-bit systems
+ * - \c BOXED_TERMS_REQUIRED_FOR_INT on 64-bit systems
+ *
+ * This effectively identifies integers that cannot be represented in the
+ * platform's native integer types and require multi-precision arithmetic,
+ * while avoiding confusion with regular boxed \c int64_t values that still
+ * fit within standard integer ranges.
+ *
+ * @param t Term to check
+ * @return true if term is a multi-precision integer, false otherwise
+ *
+ * @note Returns false for integers that fit in \c int64_t, even if boxed
+ * @note This is the correct check before calling \c term_to_bigint()
+ *
+ * @see term_to_bigint() to extract the multi-precision integer data
+ * @see term_is_boxed_integer() for checking any boxed integer
+ * @see term_is_any_integer() for checking all integer representations
+ */
+static inline bool term_is_bigint(term t)
+{
+    return term_is_boxed_integer(t)
+        && (term_boxed_size(t) > (INTN_INT64_LEN * sizeof(intn_digit_t)) / sizeof(term));
+}
+
+// intn doesn't depend on term
+_Static_assert(
+    (int) TermPositiveInteger == (int) IntNPositiveInteger, "term/intn definition mismatch");
+_Static_assert(
+    (int) TermNegativeInteger == (int) IntNNegativeInteger, "term/intn definition mismatch");
+
+/**
+ * @brief Extract multi-precision integer data from boxed term
+ *
+ * Extracts the raw multi-precision integer representation from a boxed
+ * integer term. This function provides direct access to the internal
+ * digit array without copying, returning a pointer to the data within
+ * the term structure.
+ *
+ * @param t Boxed integer term to extract from
+ * @param[out] bigint Pointer to the digit array within the term (borrowed reference)
+ * @param[out] bigint_len Number of digits in the integer
+ * @param[out] bigint_sign Sign of the integer
+ *
+ * @pre \c term_is_bigint(t) must be true
+ * @pre bigint != NULL
+ * @pre bigint_len != NULL
+ * @pre bigint_sign != NULL
+ *
+ * @warning Returned pointer is a borrowed reference into the term structure
+ * @warning Data becomes invalid if term is garbage collected or modified
+ * @warning Caller must not free the returned pointer
+ *
+ * @note The digit array may not be normalized (may have leading zeros)
+ * @note Length is calculated as boxed_size * (sizeof(term) / sizeof(intn_digit_t))
+ *
+ * @see term_is_bigint() to check if term is a multi-precision integer
+ * @see term_boxed_integer_sign() to get the sign
+ */
+static inline void term_to_bigint(
+    term t, const intn_digit_t *bigint[], size_t *bigint_len, intn_integer_sign_t *bigint_sign)
+{
+    *bigint = (const intn_digit_t *) term_intn_data(t);
+
+    const term *boxed_value = term_to_const_term_ptr(t);
+    size_t boxed_size = term_get_size_from_boxed_header(boxed_value[0]);
+    *bigint_len = boxed_size * (sizeof(term) / sizeof(intn_digit_t));
+
+    *bigint_sign = (intn_integer_sign_t) term_boxed_integer_sign(t);
+}
+
 static inline term term_from_catch_label(unsigned int module_index, unsigned int label)
 {
     return (term) ((module_index << 24) | (label << 6) | TERM_IMMED2_CATCH);