Factorize mfa as a key logic

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

Author: pguyot

src/libAtomVM/atom.c

@@ -87,19 +87,17 @@ static void utoa10(unsigned int int_value, char *integer_string)
     integer_string[integer_string_len] = '\0';
 }
 
-void atom_write_mfa(char *buf, size_t buf_size, AtomString module, AtomString function, unsigned int arity)
+void atom_write_mfa(char *buf, size_t buf_size, size_t module_name_len, const void *module_data, size_t function_name_len, const void *function_data, unsigned int arity)
 {
-    size_t module_name_len = atom_string_len(module);
-    memcpy(buf, atom_string_data(module), module_name_len);
+    memcpy(buf, module_data, module_name_len);
 
     buf[module_name_len] = ':';
 
-    size_t function_name_len = atom_string_len(function);
     if (UNLIKELY((module_name_len + 1 + function_name_len + 1 + 4 + 1 > buf_size))) {
         fprintf(stderr, "Insufficient room to write mfa.\n");
         AVM_ABORT();
     }
-    memcpy(buf + module_name_len + 1, atom_string_data(function), function_name_len);
+    memcpy(buf + module_name_len + 1, function_data, function_name_len);
 
     buf[module_name_len + function_name_len + 1] = '/';
     utoa10(arity, buf + module_name_len + 1 + function_name_len + 1);

src/libAtomVM/atom.h

@@ -99,11 +99,13 @@ static inline const void *atom_string_data(AtomString atom_str)
  *          buffer size.
  * @param   buf the buffer to write into
  * @param   buf_size the amount of room in the buffer
- * @param   module the module name
- * @param   function the function name
+ * @param   module_name_len length of the module name
+ * @param   module_data the module name
+ * @param   function_name_len length of the function name
+ * @param   function_data the function name
  * @param   arity the function arity
  */
-void atom_write_mfa(char *buf, size_t buf_size, AtomString module, AtomString function, unsigned int arity);
+void atom_write_mfa(char *buf, size_t buf_size, size_t module_name_len, const void *module_data, size_t function_name_len, const void *function_data, unsigned int arity);
 
 #ifdef __cplusplus
 }

src/libAtomVM/bif.c

@@ -57,12 +57,9 @@
         RAISE_ERROR_BIF(fail_label, BADARG_ATOM);              \
     }
 
-const struct ExportedFunction *bif_registry_get_handler(AtomString module, AtomString function, int arity)
+const struct ExportedFunction *bif_registry_get_handler(const char *mfa)
 {
-    char bifname[MAX_BIF_NAME_LEN];
-
-    atom_write_mfa(bifname, MAX_BIF_NAME_LEN, module, function, arity);
-    const BifNameAndPtr *nameAndPtr = in_word_set(bifname, strlen(bifname));
+    const BifNameAndPtr *nameAndPtr = in_word_set(mfa, strlen(mfa));
     if (!nameAndPtr) {
         return NULL;
     }

src/libAtomVM/bif.h

@@ -39,7 +39,7 @@ extern "C" {
 
 #define MAX_BIF_NAME_LEN 260
 
-const struct ExportedFunction *bif_registry_get_handler(AtomString module, AtomString function, int arity);
+const struct ExportedFunction *bif_registry_get_handler(const char *mfa);
 
 term bif_erlang_self_0(Context *ctx);
 term bif_erlang_byte_size_1(Context *ctx, uint32_t fail_label, int live, term arg1);

src/libAtomVM/nifs.c

@@ -58,7 +58,6 @@
 #include "unicode.h"
 #include "utils.h"
 
-#define MAX_NIF_NAME_LEN 260
 #define FLOAT_BUF_SIZE 64
 
 #define RAISE(a, b)  \
@@ -873,30 +872,11 @@ DEFINE_MATH_NIF(tanh)
 #include "nifs_hash.h"
 #pragma GCC diagnostic pop
 
-const struct Nif *nifs_get(AtomString module, AtomString function, int arity)
+const struct Nif *nifs_get(const char *mfa)
 {
-    char nifname[MAX_NIF_NAME_LEN];
-
-    int module_name_len = atom_string_len(module);
-    memcpy(nifname, atom_string_data(module), module_name_len);
-
-    nifname[module_name_len] = ':';
-
-    int function_name_len = atom_string_len(function);
-    if (UNLIKELY((arity > 9) || (module_name_len + function_name_len + 4 > MAX_NIF_NAME_LEN))) {
-        // In AtomVM NIFs are limited to 9 parameters
-        return NULL;
-    }
-    memcpy(nifname + module_name_len + 1, atom_string_data(function), function_name_len);
-
-    //TODO: handle NIFs with more than 9 parameters
-    nifname[module_name_len + function_name_len + 1] = '/';
-    nifname[module_name_len + function_name_len + 2] = '0' + arity;
-    nifname[module_name_len + function_name_len + 3] = 0;
-
-    const NifNameAndNifPtr *nameAndPtr = nif_in_word_set(nifname, strlen(nifname));
+    const NifNameAndNifPtr *nameAndPtr = nif_in_word_set(mfa, strlen(mfa));
     if (!nameAndPtr) {
-        return platform_nifs_get_nif(nifname);
+        return platform_nifs_get_nif(mfa);
     }
 
     return nameAndPtr->nif;
@@ -3476,16 +3456,20 @@ static term nif_erlang_function_exported(Context *ctx, int argc, term argv[])
     VALIDATE_VALUE(function, term_is_atom);
     VALIDATE_VALUE(arity_term, term_is_integer);
 
-    AtomString module_name = globalcontext_atomstring_from_term(ctx->global, module);
-    AtomString function_name = globalcontext_atomstring_from_term(ctx->global, function);
+    AtomIndex module_name = term_to_atom_index(module);
+    AtomIndex function_name = term_to_atom_index(function);
+
     avm_int_t arity = term_to_int(arity_term);
 
-    const struct ExportedFunction *bif = bif_registry_get_handler(module_name, function_name, arity);
+    char mfa[MAX_MFA_NAME_LEN];
+    atom_table_write_mfa(ctx->global->atom_table, mfa, sizeof(mfa), module_name, function_name, arity);
+
+    const struct ExportedFunction *bif = bif_registry_get_handler(mfa);
     if (bif) {
         return TRUE_ATOM;
     }
 
-    struct Nif *nif = (struct Nif *) nifs_get(module_name, function_name, arity);
+    struct Nif *nif = (struct Nif *) nifs_get(mfa);
     if (nif) {
         return TRUE_ATOM;
     }
@@ -3495,7 +3479,7 @@ static term nif_erlang_function_exported(Context *ctx, int argc, term argv[])
         return FALSE_ATOM;
     }
 
-    int target_label = module_search_exported_function(target_module, function_name, arity, ctx->global);
+    int target_label = module_search_exported_function(target_module, function_name, arity);
     if (target_label == 0) {
         return FALSE_ATOM;
     }
@@ -3625,20 +3609,20 @@ static term nif_erlang_fun_info_2(Context *ctx, int argc, term argv[])
     switch (key) {
         case MODULE_ATOM: {
             term module_name;
-            term_get_function_mfa(fun, &module_name, NULL, NULL, ctx->global);
+            term_get_function_mfa(fun, &module_name, NULL, NULL);
             value = module_name;
             break;
         }
         case NAME_ATOM: {
             term function_name;
-            term_get_function_mfa(fun, NULL, &function_name, NULL, ctx->global);
+            term_get_function_mfa(fun, NULL, &function_name, NULL);
             value = function_name;
             break;
         }
 
         case ARITY_ATOM: {
             term arity;
-            term_get_function_mfa(fun, NULL, NULL, &arity, ctx->global);
+            term_get_function_mfa(fun, NULL, NULL, &arity);
             value = arity;
             break;
         }
@@ -3977,7 +3961,7 @@ static term nif_erlang_get_module_info(Context *ctx, int argc, term argv[])
     if (UNLIKELY(memory_ensure_free(ctx, info_size) != MEMORY_GC_OK)) {
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
     }
-    term exports = module_get_exported_functions(target_module, &ctx->heap, ctx->global);
+    term exports = module_get_exported_functions(target_module, &ctx->heap);
     if (argc == 2) {
         return exports;
     }

src/libAtomVM/nifs.h

@@ -46,7 +46,7 @@ extern "C" {
     ctx->x[1] = (error_type_atom);   \
     return term_invalid_term();
 
-const struct Nif *nifs_get(AtomString module, AtomString function, int arity);
+const struct Nif *nifs_get(const char *mfa);
 
 #ifdef __cplusplus
 }