Use size_t for Janet types length and capacity and the API those types use

examples/numarray/numarray.c

@@ -70,7 +70,7 @@ void num_array_put(void *p, Janet key, Janet value) {
     if (!janet_checktype(value, JANET_NUMBER))
         janet_panic("expected number value");
 
-    index = (size_t)janet_unwrap_integer(key);
+    index = janet_unwrap_size(key);
     if (index < array->size) {
         array->data[index] = janet_unwrap_number(value);
     }
@@ -96,7 +96,7 @@ int num_array_get(void *p, Janet key, Janet *out) {
         return janet_getmethod(janet_unwrap_keyword(key), methods, out);
     if (!janet_checkint(key))
         janet_panic("expected integer key");
-    index = (size_t)janet_unwrap_integer(key);
+    index = janet_unwrap_size(key);
     if (index >= array->size) {
         return 0;
     } else {

src/boot/array_test.c

@@ -26,8 +26,6 @@
 #include "tests.h"
 
 int array_test() {
-
-    int i;
     JanetArray *array1, *array2;
 
     array1 = janet_array(10);
@@ -53,7 +51,7 @@ int array_test() {
     janet_array_push(array2, janet_cstringv("six"));
     janet_array_push(array2, janet_cstringv("seven"));
 
-    for (i = 0; i < array2->count; i++) {
+    for (size_t i = 0; i < array2->count; i++) {
         assert(janet_equals(array1->data[i], array2->data[i]));
     }
 

src/boot/boot.c

@@ -104,7 +104,7 @@ int main(int argc, const char **argv) {
     }
     fclose(boot_file);
 
-    status = janet_dobytes(env, boot_buffer, (int32_t) boot_size, boot_filename, NULL);
+    status = janet_dobytes(env, boot_buffer, boot_size, boot_filename, NULL);
     janet_free(boot_buffer);
 
     /* Deinitialize vm */

src/boot/buffer_test.c

@@ -26,8 +26,6 @@
 #include "tests.h"
 
 int buffer_test() {
-
-    int i;
     JanetBuffer *buffer1, *buffer2;
 
     buffer1 = janet_buffer(100);
@@ -54,7 +52,7 @@ int buffer_test() {
     assert(buffer1->capacity >= buffer1->count);
     assert(buffer2->capacity >= buffer2->count);
 
-    for (i = 0; i < buffer1->count; i++) {
+    for (size_t i = 0; i < buffer1->count; i++) {
         assert(buffer1->data[i] == buffer2->data[i]);
     }
 

src/boot/number_test.c

@@ -38,7 +38,7 @@ static void test_valid_str(const char *str) {
     double cnum, jnum;
     jnum = 0.0;
     cnum = atof(str);
-    err = janet_scan_number((const uint8_t *) str, (int32_t) strlen(str), &jnum);
+    err = janet_scan_number((const uint8_t *) str, strlen(str), &jnum);
     assert(!err);
     assert(cnum == jnum);
 }

src/core/array.c

@@ -30,11 +30,11 @@
 
 #include <string.h>
 
-static void janet_array_impl(JanetArray *array, int32_t capacity) {
+static void janet_array_impl(JanetArray *array, size_t capacity) {
     Janet *data = NULL;
     if (capacity > 0) {
         janet_vm.next_collection += capacity * sizeof(Janet);
-        data = (Janet *) janet_malloc(sizeof(Janet) * (size_t) capacity);
+        data = (Janet *) janet_malloc(sizeof(Janet) * capacity);
         if (NULL == data) {
             JANET_OUT_OF_MEMORY;
         }
@@ -45,25 +45,25 @@ static void janet_array_impl(JanetArray *array, int32_t capacity) {
 }
 
 /* Creates a new array */
-JanetArray *janet_array(int32_t capacity) {
+JanetArray *janet_array(size_t capacity) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     janet_array_impl(array, capacity);
     return array;
 }
 
 /* Creates a new array with weak references */
-JanetArray *janet_array_weak(int32_t capacity) {
+JanetArray *janet_array_weak(size_t capacity) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray));
     janet_array_impl(array, capacity);
     return array;
 }
 
 /* Creates a new array from n elements. */
-JanetArray *janet_array_n(const Janet *elements, int32_t n) {
+JanetArray *janet_array_n(const Janet *elements, size_t n) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     array->capacity = n;
     array->count = n;
-    array->data = janet_malloc(sizeof(Janet) * (size_t) n);
+    array->data = janet_malloc(sizeof(Janet) * n);
     if (!array->data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -72,13 +72,13 @@ JanetArray *janet_array_n(const Janet *elements, int32_t n) {
 }
 
 /* Ensure the array has enough capacity for elements */
-void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
+void janet_array_ensure(JanetArray *array, size_t capacity, size_t growth) {
     Janet *newData;
     Janet *old = array->data;
     if (capacity <= array->capacity) return;
-    int64_t new_capacity = ((int64_t) capacity) * growth;
-    if (new_capacity > INT32_MAX) new_capacity = INT32_MAX;
-    capacity = (int32_t) new_capacity;
+    size_t new_capacity = (capacity) * growth;
+    if (new_capacity > JANET_INTMAX_SIZE) new_capacity = JANET_INTMAX_SIZE;
+    capacity = new_capacity;
     newData = janet_realloc(old, capacity * sizeof(Janet));
     if (NULL == newData) {
         JANET_OUT_OF_MEMORY;
@@ -89,11 +89,9 @@ void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
 }
 
 /* Set the count of an array. Extend with nil if needed. */
-void janet_array_setcount(JanetArray *array, int32_t count) {
-    if (count < 0)
-        return;
+void janet_array_setcount(JanetArray *array, size_t count) {
     if (count > array->count) {
-        int32_t i;
+        size_t i;
         janet_array_ensure(array, count, 1);
         for (i = array->count; i < count; i++) {
             array->data[i] = janet_wrap_nil();
@@ -104,10 +102,10 @@ void janet_array_setcount(JanetArray *array, int32_t count) {
 
 /* Push a value to the top of the array */
 void janet_array_push(JanetArray *array, Janet x) {
-    if (array->count == INT32_MAX) {
+    if (array->count == JANET_INTMAX_SIZE) {
         janet_panic("array overflow");
     }
-    int32_t newcount = array->count + 1;
+    size_t newcount = array->count + 1;
     janet_array_ensure(array, newcount, 2);
     array->data[array->count] = x;
     array->count = newcount;
@@ -138,7 +136,7 @@ JANET_CORE_FN(cfun_array_new,
               "Creates a new empty array with a pre-allocated capacity. The same as "
               "`(array)` but can be more efficient if the maximum size of an array is known.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     JanetArray *array = janet_array(cap);
     return janet_wrap_array(array);
 }
@@ -147,7 +145,7 @@ JANET_CORE_FN(cfun_array_weak,
               "(array/weak capacity)",
               "Creates a new empty array with a pre-allocated capacity and support for weak references. Similar to `array/new`.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     JanetArray *array = janet_array_weak(cap);
     return janet_wrap_array(array);
 }
@@ -156,10 +154,10 @@ JANET_CORE_FN(cfun_array_new_filled,
               "(array/new-filled count &opt value)",
               "Creates a new array of `count` elements, all set to `value`, which defaults to nil. Returns the new array.") {
     janet_arity(argc, 1, 2);
-    int32_t count = janet_getnat(argv, 0);
+    size_t count = janet_getsize(argv, 0);
     Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
     JanetArray *array = janet_array(count);
-    for (int32_t i = 0; i < count; i++) {
+    for (size_t i = 0; i < count; i++) {
         array->data[i] = x;
     }
     array->count = count;
@@ -173,7 +171,7 @@ JANET_CORE_FN(cfun_array_fill,
     janet_arity(argc, 1, 2);
     JanetArray *array = janet_getarray(argv, 0);
     Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
-    for (int32_t i = 0; i < array->count; i++) {
+    for (size_t i = 0; i < array->count; i++) {
         array->data[i] = x;
     }
     return argv[0];
@@ -201,10 +199,10 @@ JANET_CORE_FN(cfun_array_push,
               "Push all the elements of xs to the end of an array. Modifies the input array and returns it.") {
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    if (INT32_MAX - argc + 1 <= array->count) {
+    if ((size_t) JANET_INTMAX_SIZE - argc + 1 <= array->count) {
         janet_panic("array overflow");
     }
-    int32_t newcount = array->count - 1 + argc;
+    size_t newcount = array->count - 1 + argc;
     janet_array_ensure(array, newcount, 2);
     if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet));
     array->count = newcount;
@@ -219,8 +217,8 @@ JANET_CORE_FN(cfun_array_ensure,
               "Otherwise, the backing memory will be reallocated so that there is enough space.") {
     janet_fixarity(argc, 3);
     JanetArray *array = janet_getarray(argv, 0);
-    int32_t newcount = janet_getinteger(argv, 1);
-    int32_t growth = janet_getinteger(argv, 2);
+    size_t newcount = janet_getsize(argv, 1);
+    size_t growth = janet_getsize(argv, 2);
     if (newcount < 1) janet_panic("expected positive integer");
     janet_array_ensure(array, newcount, growth);
     return argv[0];
@@ -248,21 +246,20 @@ JANET_CORE_FN(cfun_array_concat,
               "which must be an array. If any of the parts are arrays or tuples, their elements will "
               "be inserted into the array. Otherwise, each part in `parts` will be appended to `arr` in order. "
               "Return the modified array `arr`.") {
-    int32_t i;
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    for (i = 1; i < argc; i++) {
+    for (int32_t i = 1; i < argc; i++) {
         switch (janet_type(argv[i])) {
             default:
                 janet_array_push(array, argv[i]);
                 break;
             case JANET_ARRAY:
             case JANET_TUPLE: {
-                int32_t j, len = 0;
+                size_t j, len = 0;
                 const Janet *vals = NULL;
                 janet_indexed_view(argv[i], &vals, &len);
                 if (array->data == vals) {
-                    int32_t newcount = array->count + len;
+                    size_t newcount = array->count + len;
                     janet_array_ensure(array, newcount, 2);
                     janet_indexed_view(argv[i], &vals, &len);
                 }
@@ -284,15 +281,15 @@ JANET_CORE_FN(cfun_array_insert,
     size_t chunksize, restsize;
     janet_arity(argc, 2, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    int32_t at = janet_getinteger(argv, 1);
+    ssize_t at = janet_getssize(argv, 1);
     if (at < 0) {
         at = array->count + at + 1;
     }
-    if (at < 0 || at > array->count)
-        janet_panicf("insertion index %d out of range [0,%d]", at, array->count);
+    if (at < 0 || (size_t) at > array->count)
+      janet_panicf("insertion index %d out of range [0,%d]", at, array->count);
     chunksize = (argc - 2) * sizeof(Janet);
     restsize = (array->count - at) * sizeof(Janet);
-    if (INT32_MAX - (argc - 2) < array->count) {
+    if ((size_t) JANET_INTMAX_SIZE - (argc - 2) < array->count) {
         janet_panic("array overflow");
     }
     janet_array_ensure(array, array->count + argc - 2, 2);
@@ -314,17 +311,15 @@ JANET_CORE_FN(cfun_array_remove,
               "Returns the array.") {
     janet_arity(argc, 2, 3);
     JanetArray *array = janet_getarray(argv, 0);
-    int32_t at = janet_getinteger(argv, 1);
-    int32_t n = 1;
+    ssize_t at = janet_getssize(argv, 1);
+    size_t n = 1;
     if (at < 0) {
         at = array->count + at;
     }
-    if (at < 0 || at > array->count)
+    if (at < 0 || (size_t) at > array->count)
         janet_panicf("removal index %d out of range [0,%d]", at, array->count);
     if (argc == 3) {
-        n = janet_getinteger(argv, 2);
-        if (n < 0)
-            janet_panicf("expected non-negative integer for argument n, got %v", argv[2]);
+        n = janet_getsize(argv, 2);
     }
     if (at + n > array->count) {
         n = array->count - at;

src/core/asm.c

@@ -282,7 +282,7 @@
         case JANET_TUPLE: {
             const Janet *t = janet_unwrap_tuple(x);
             if (argtype == JANET_OAT_TYPE) {
-                int32_t i = 0;
+                size_t i = 0;
                 ret = 0;
                 for (i = 0; i < janet_tuple_length(t); i++) {
                     ret |= doarg_1(a, JANET_OAT_SIMPLETYPE, t[i]);
@@ -492,7 +492,7 @@
     JanetAssembler a;
     Janet s = source;
     JanetFuncDef *def;
-    int32_t count, i;
+    size_t count, i;
     const Janet *arr;
     Janet x;
     (void) flags;
@@ -578,8 +578,7 @@
             Janet v = arr[i];
             if (janet_checktype(v, JANET_TUPLE)) {
                 const Janet *t = janet_unwrap_tuple(v);
-                int32_t j;
-                for (j = 0; j < janet_tuple_length(t); j++) {
+                for (size_t j = 0; j < janet_tuple_length(t); j++) {
                     if (!janet_checktype(t[j], JANET_SYMBOL))
                         janet_asm_error(&a, "slot names must be symbols");
                     janet_table_put(&a.slots, t[j], janet_wrap_integer(i));
@@ -596,7 +595,7 @@
     x = janet_get1(s, janet_ckeywordv("constants"));
     if (janet_indexed_view(x, &arr, &count)) {
         def->constants_length = count;
-        def->constants = janet_malloc(sizeof(Janet) * (size_t) count);
+        def->constants = janet_malloc(sizeof(Janet) * count);
         if (NULL == def->constants) {
             JANET_OUT_OF_MEMORY;
         }
@@ -615,8 +614,7 @@
         x = janet_get1(s, janet_ckeywordv("defs"));
     }
     if (janet_indexed_view(x, &arr, &count)) {
-        int32_t i;
-        for (i = 0; i < count; i++) {
+        for (size_t i = 0; i < count; i++) {
             JanetAssembleResult subres;
             Janet subname;
             int32_t newlen;
@@ -701,7 +699,7 @@
     /* Check for source mapping */
     x = janet_get1(s, janet_ckeywordv("sourcemap"));
     if (janet_indexed_view(x, &arr, &count)) {
-        janet_asm_assert(&a, count == def->bytecode_length, "sourcemap must have the same length as the bytecode");
+        janet_asm_assert(&a, count == (size_t) def->bytecode_length, "sourcemap must have the same length as the bytecode");
         def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) count);
         if (NULL == def->sourcemap) {
             JANET_OUT_OF_MEMORY;
@@ -775,7 +773,7 @@
         if (def->environments_length) {
             def->environments = janet_realloc(def->environments, def->environments_length * sizeof(int32_t));
         }
-        for (int32_t i = 0; i < count; i++) {
+        for (size_t i = 0; i < count; i++) {
             if (!janet_checkint(arr[i])) {
                 janet_asm_error(&a, "expected integer");
             }