bsr cleanup #1

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

Author: bettio

src/libAtomVM/intn.c

@@ -612,47 +612,34 @@ size_t intn_bsl(const uint32_t num[], size_t len, size_t n, uint32_t *out)
     return initial_zeros + i;
 }
 
-size_t bsru(const uint32_t num[], size_t effective_bits_len, size_t n, uint32_t last_digit, uint32_t *out)
+void bsru(const uint32_t num[], size_t effective_bits_len, size_t n, uint32_t last_digit, uint32_t *out)
 {
-    size_t digit_bit_size = sizeof(uint32_t) * 8;
-
-    size_t digit_right_bit_shift = n % 32;
-    size_t left_shift_n = (32 - digit_right_bit_shift);
-
-    size_t len = size_round_to(effective_bits_len, digit_bit_size) / digit_bit_size;
-    size_t counted_digits = len;
+    size_t digit_bit_size = sizeof(uint32_t) * 8; // 32
 
-    ///size_t new_bits_len = size_round_to(effective_bits_len - n, digit_bit_size);
+    size_t digit_right_bit_shift = n % digit_bit_size;
+    size_t left_shift_n = (digit_bit_size - digit_right_bit_shift);
 
-    ////size_t new_digits_count = new_bits_len / digit_bit_size;
+    size_t len_in_digits = size_round_to(effective_bits_len, digit_bit_size) / digit_bit_size;
 
-    size_t discarded = MIN(n / digit_bit_size, len);
+    // caller makes sure that discarded < len_in_digits
+    size_t discarded = n / digit_bit_size;
 
     if (left_shift_n == 32) {
-        memcpy(out, num + discarded, (len - discarded) * sizeof(uint32_t));
-        return len - discarded;
+        memcpy(out, num + discarded, (len_in_digits - discarded) * sizeof(uint32_t));
+        return;
     }
 
     size_t i;
-    for (i = discarded; i < counted_digits - 1; i++) {
+    for (i = discarded; i < len_in_digits - 1; i++) {
         uint32_t next_digit = num[i + 1];
         uint32_t digit = num[i];
         out[i - discarded] = (digit >> digit_right_bit_shift) | (next_digit << left_shift_n);
     }
     uint32_t maybe_last_out = (num[i] >> digit_right_bit_shift) | (last_digit << left_shift_n);
 
-/*
-    if (initial_zeros + i > new_digits_count) {
-        abort();
-    }
-*/
-
     if (maybe_last_out) {
         out[i - discarded] = maybe_last_out;
-        return i - discarded + 1;
     }
-
-    return i - discarded;
 }
 
 size_t intn_bsr(const uint32_t num[], size_t len, intn_integer_sign_t num_sign, size_t n, uint32_t *out)
@@ -662,29 +649,25 @@ size_t intn_bsr(const uint32_t num[], size_t len, intn_integer_sign_t num_sign,
     size_t ms_digit_bits = 32 - uint32_nlz(num[counted_digits - 1]);
     size_t effective_bits_len = (counted_digits - 1) * digit_bit_size + ms_digit_bits;
 
-    if (n > effective_bits_len) {
+    if (n >= effective_bits_len) {
         out[0] = (num_sign == IntNPositiveInteger) ? 0 : 1;
         return 1;
     }
 
+    size_t shifted_len = size_round_to(effective_bits_len - n, digit_bit_size) / digit_bit_size; 
+
     if (num_sign == IntNPositiveInteger) {
-        return bsru(num, effective_bits_len, n, 0, out);
+        bsru(num, effective_bits_len, n, 0, out);
+
     } else {
         uint32_t tmp_buf[INTN_MAX_RES_LEN];
-        memset(out, 0, INTN_MAX_RES_LEN * sizeof(const uint32_t));
         neg(num, counted_digits, tmp_buf);
-        size_t shifted_len = bsru(tmp_buf, effective_bits_len, n, (uint32_t) -1, out);
-
-        size_t len = size_round_to(effective_bits_len - n, digit_bit_size) / digit_bit_size;
-        neg_in_place(out, len);
-
-        fprintf(stderr, "shifted: %i, len: %i\n", (int) shifted_len, (int) len);
-        print_num(out, len);
-        return len;
+        bsru(tmp_buf, effective_bits_len, n, (uint32_t) -1, out);
+        neg_in_place(out, shifted_len);
     }
-}
-
 
+    return shifted_len;
+}
 
 /*
     uint32_t last_digit = 0;