Introduce AtomIndex type

Also introduce a type for the result of atom_table_ensure_atoms, which isn't
an AtomIndex.

Signed-off-by: Paul Guyot <pguyot@kallisys.net>

Author: pguyot

src/libAtomVM/atom.h

@@ -45,6 +45,7 @@ extern "C" {
 #define ATOM_STR(LENSTR, STR) (LENSTR STR)
 
 typedef const void *AtomString;
+typedef uint32_t AtomIndex;
 
 /**
  * @brief Gets a C string from an AtomString

src/libAtomVM/atom_table.c

@@ -188,7 +188,7 @@ static inline struct HNode *get_node(const struct AtomTable *hash_table, AtomStr
     return get_node_with_hash(hash_table, string, hash);
 }
 
-long atom_table_get_index(struct AtomTable *table, AtomString string)
+AtomIndex atom_table_get_index(struct AtomTable *table, AtomString string)
 {
     unsigned long hash = sdbm_hash(string, atom_string_len(string));
 
@@ -202,7 +202,7 @@ long atom_table_get_index(struct AtomTable *table, AtomString string)
 }
 
 // TODO: this function needs use an efficient structure such as a skip list
-static struct HNode *get_node_using_index(struct AtomTable *table, long index)
+static struct HNode *get_node_using_index(struct AtomTable *table, AtomIndex index)
 {
     if (UNLIKELY(((size_t) index) >= table->count)) {
         return NULL;
@@ -221,7 +221,7 @@ static struct HNode *get_node_using_index(struct AtomTable *table, long index)
     return NULL;
 }
 
-AtomString atom_table_get_atom_string(struct AtomTable *table, long index)
+AtomString atom_table_get_atom_string(struct AtomTable *table, AtomIndex index)
 {
     SMP_RDLOCK(table);
 
@@ -264,7 +264,7 @@ int atom_table_cmp_using_atom_index(struct AtomTable *table, int t_atom_index, i
     return memcmp_result;
 }
 
-atom_ref_t atom_table_get_atom_ptr_and_len(struct AtomTable *table, long index, size_t *out_len)
+atom_ref_t atom_table_get_atom_ptr_and_len(struct AtomTable *table, AtomIndex index, size_t *out_len)
 {
     SMP_RDLOCK(table);
 
@@ -398,7 +398,7 @@ static inline bool maybe_rehash(struct AtomTable *table, int new_entries)
     return do_rehash(table, new_capacity);
 }
 
-long atom_table_ensure_atom(struct AtomTable *table, AtomString string, enum AtomTableCopyOpt opts)
+AtomIndex atom_table_ensure_atom(struct AtomTable *table, AtomString string, enum AtomTableCopyOpt opts)
 {
     unsigned long hash = sdbm_hash(string, atom_string_len(string));
     SMP_WRLOCK(table);
@@ -463,8 +463,8 @@ static inline int read_encoded_len(const uint8_t **len_bytes)
     }
 }
 
-int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int count,
-    int *translate_table, enum EnsureAtomsOpt opt)
+enum AtomTableEnsureAtomsResult atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int count,
+    AtomIndex *translate_table, enum EnsureAtomsOpt opt)
 {
     bool is_long_format = (opt & EnsureLongEncoding) != 0;
 
@@ -481,7 +481,7 @@ int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int coun
             if (UNLIKELY(atom_len < 0)) {
                 fprintf(stderr, "Found invalid atom len.");
                 SMP_UNLOCK(table);
-                return ATOM_TABLE_INVALID_LEN;
+                return AtomTableEnsureAtomsInvalidLen;
             } else if (UNLIKELY(atom_len > 255)) {
                 fprintf(stderr,
                     "Unsupported atom length %i bytes.\n"
@@ -491,7 +491,7 @@ int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int coun
                     "https://github.com/atomvm/AtomVM/issues\n",
                     atom_len);
                 SMP_UNLOCK(table);
-                return ATOM_TABLE_INVALID_LEN;
+                return AtomTableEnsureAtomsInvalidLen;
             }
             char tmp_old_fmt[256];
             tmp_old_fmt[0] = atom_len;
@@ -536,7 +536,7 @@ int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int coun
                 node_group = new_node_group(table, remaining_atoms);
                 if (IS_NULL_PTR(node_group)) {
                     SMP_UNLOCK(table);
-                    return ATOM_TABLE_ALLOC_FAIL;
+                    return AtomTableEnsureAtomsAllocFail;
                 }
             }
 
@@ -545,7 +545,7 @@ int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int coun
                 if (IS_NULL_PTR(atom_copy)) {
                     // we are not going to remove atoms that have already been added up to this one
                     SMP_UNLOCK(table);
-                    return ATOM_TABLE_ALLOC_FAIL;
+                    return AtomTableEnsureAtomsAllocFail;
                 }
                 atom_copy[0] = atom_len;
                 memcpy(atom_copy + 1, to_be_copied, atom_len);
@@ -566,5 +566,5 @@ int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int coun
 
     SMP_UNLOCK(table);
 
-    return 0;
+    return AtomTableEnsureAtomsOk;
 }

src/libAtomVM/atom_table.h

@@ -29,9 +29,8 @@
 extern "C" {
 #endif
 
-#define ATOM_TABLE_NOT_FOUND -1
-#define ATOM_TABLE_ALLOC_FAIL -2
-#define ATOM_TABLE_INVALID_LEN -3
+#define ATOM_TABLE_NOT_FOUND ((AtomIndex) -1)
+#define ATOM_TABLE_ALLOC_FAIL ((AtomIndex) -2)
 
 struct AtomTable;
 
@@ -48,27 +47,34 @@ enum AtomTableCopyOpt
     AtomTableAlreadyExisting = 2
 };
 
+enum AtomTableEnsureAtomsResult
+{
+    AtomTableEnsureAtomsOk = 0,
+    AtomTableEnsureAtomsAllocFail = -2,
+    AtomTableEnsureAtomsInvalidLen = -3,
+};
+
 typedef const void *atom_ref_t;
 
 struct AtomTable *atom_table_new();
 void atom_table_destroy(struct AtomTable *table);
 
 size_t atom_table_count(struct AtomTable *table);
 
-long atom_table_ensure_atom(struct AtomTable *table, AtomString string, enum AtomTableCopyOpt opts);
+AtomIndex atom_table_ensure_atom(struct AtomTable *table, AtomString string, enum AtomTableCopyOpt opts);
 
 // This function is deprecated and it will be removed.
 // atom strings should be copied to caller owned buffers.
-AtomString atom_table_get_atom_string(struct AtomTable *table, long index);
+AtomString atom_table_get_atom_string(struct AtomTable *table, AtomIndex index);
 
-long atom_table_get_index(struct AtomTable *table, AtomString string);
+AtomIndex atom_table_get_index(struct AtomTable *table, AtomString string);
 
-int atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int count,
-    int *translate_table, enum EnsureAtomsOpt opts);
+enum AtomTableEnsureAtomsResult atom_table_ensure_atoms(struct AtomTable *table, const void *atoms, int count,
+    AtomIndex *translate_table, enum EnsureAtomsOpt opts);
 
 int atom_table_cmp_using_atom_index(
     struct AtomTable *table, int t_atom_index, int other_atom_index);
-atom_ref_t atom_table_get_atom_ptr_and_len(struct AtomTable *table, long index, size_t *out_len);
+atom_ref_t atom_table_get_atom_ptr_and_len(struct AtomTable *table, AtomIndex index, size_t *out_len);
 bool atom_table_is_atom_ref_ascii(struct AtomTable *table, atom_ref_t atom);
 void atom_table_write_bytes(struct AtomTable *table, atom_ref_t atom, size_t buf_len, void *outbuf);
 void atom_table_write_cstring(

src/libAtomVM/module.c

@@ -81,16 +81,20 @@ static enum ModuleLoadResult module_populate_atoms_table(Module *this_module, ui
         return MODULE_ERROR_FAILED_ALLOCATION;
     }
 
-    long ensure_result = atom_table_ensure_atoms(
+    enum AtomTableEnsureAtomsResult ensure_result = atom_table_ensure_atoms(
         glb->atom_table, current_atom, atoms_count, this_module->local_atoms_to_global_table + 1, ensure_opts);
-    if (UNLIKELY(ensure_result == ATOM_TABLE_ALLOC_FAIL)) {
-        fprintf(stderr, "Cannot allocate memory while loading module (line: %i).\n", __LINE__);
-        return MODULE_ERROR_FAILED_ALLOCATION;
-    } else if (UNLIKELY(ensure_result == ATOM_TABLE_INVALID_LEN)) {
-        return MODULE_ERROR_INVALID;
+    switch (ensure_result) {
+        case AtomTableEnsureAtomsAllocFail: {
+            fprintf(stderr, "Cannot allocate memory while loading module (line: %i).\n", __LINE__);
+            return MODULE_ERROR_FAILED_ALLOCATION;
+        }
+        case AtomTableEnsureAtomsInvalidLen: {
+            return MODULE_ERROR_INVALID;
+        }
+        case AtomTableEnsureAtomsOk: {
+            return MODULE_LOAD_OK;            
+        }
     }
-
-    return MODULE_LOAD_OK;
 }
 
 static enum ModuleLoadResult module_build_imported_functions_table(Module *this_module, uint8_t *table_data, GlobalContext *glb)

src/libAtomVM/module.h

@@ -123,7 +123,7 @@ struct Module
 
     struct LiteralEntry *literals_table;
 
-    int *local_atoms_to_global_table;
+    AtomIndex *local_atoms_to_global_table;
 
     void *module_platform_data;
 

src/libAtomVM/term.h

@@ -37,6 +37,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "atom.h"
 #include "memory.h"
 #include "refc_binary.h"
 #include "utils.h"
@@ -599,7 +600,7 @@ static inline term term_nil()
  * @param t the term that will be converted to atom table index. t must be a valid atom term.
  * @return a global atom table index.
  */
-static inline int term_to_atom_index(term t)
+static inline AtomIndex term_to_atom_index(term t)
 {
     return t >> 6;
 }
@@ -611,7 +612,7 @@ static inline int term_to_atom_index(term t)
  * @param atom_index global atoms table index.
  * @return a term that encapsulates the atom.
  */
-static inline term term_from_atom_index(int atom_index)
+static inline term term_from_atom_index(AtomIndex atom_index)
 {
     return TERM_FROM_ATOM_INDEX(atom_index);
 }

tests/test-structs.c

@@ -274,9 +274,9 @@ void test_valueshashtable()
     }
 }
 
-int insert_atoms_into_atom_table(struct AtomTable *table)
+AtomIndex insert_atoms_into_atom_table(struct AtomTable *table)
 {
-    int decimals_index;
+    AtomIndex decimals_index;
 
     atom_table_ensure_atom(table, false_atom, AtomTableNoOpts);
     atom_table_ensure_atom(table, true_atom, AtomTableNoOpts);
@@ -431,7 +431,7 @@ void test_atom_table()
 
     assert(((char *) atom_table_get_atom_string(table, 0))[0] == 3);
 
-    int decimals_index = insert_atoms_into_atom_table(table);
+    AtomIndex decimals_index = insert_atoms_into_atom_table(table);
 
     assert(atom_table_get_index(table, "\x8" "decimals") == decimals_index);
     assert(atom_table_ensure_atom(table, "\x8" "decimals", AtomTableNoOpts) == decimals_index);