term.c: add a generic term_funprint function

Make term printing generic by taking a printer function.

Signed-off-by: Davide Bettio <[email protected]>

Author: bettio

src/libAtomVM/term.c

@@ -28,29 +28,71 @@
 
 #include <ctype.h>
 #include <inttypes.h>
+#include <stdarg.h>
+#include <stddef.h>
 #include <stdio.h>
 
+//TODO use macro from utils
+#ifndef CONTAINER_OF
+#define CONTAINER_OF(ptr, type, member) \
+    ((type *) (((char *) (ptr)) - offsetof(type, member)))
+#endif
+
+struct FprintfFun
+{
+    PrinterFun base;
+    FILE *stream;
+};
+
 const term empty_tuple = 0;
 
+int fprintf_printer(PrinterFun *fun, const char *fmt, ...)
+{
+    int ret;
+
+    va_list args;
+    va_start(args, fmt);
+
+    FILE *stream = CONTAINER_OF(fun, struct FprintfFun, base)->stream;
+    ret = vfprintf(stream, fmt, args);
+
+    va_end(args);
+
+    return ret;
+}
+
 void term_display(FILE *fd, term t, const Context *ctx)
 {
     term_fprint(fd, t, ctx->global);
 }
 
-void term_fprint(FILE *fd, term t, const GlobalContext *global)
+int term_fprint(FILE *stream, term t, const GlobalContext *global)
+{
+    struct FprintfFun fprintf_fun = {
+        .base = {
+            .print = fprintf_printer
+        },
+        .stream = stream
+    };
+
+    return term_funprint(&fprintf_fun.base, t, global);
+}
+
+int term_funprint(PrinterFun *fun, term t, const GlobalContext *global)
 {
     if (term_is_atom(t)) {
         int atom_index = term_to_atom_index(t);
         AtomString atom_string = (AtomString) valueshashtable_get_value(
             global->atoms_ids_table, atom_index, (unsigned long) NULL);
-        fprintf(fd, "%.*s", (int) atom_string_len(atom_string), (char *) atom_string_data(atom_string));
+        return fun->print(fun, "%.*s", (int) atom_string_len(atom_string),
+            (char *) atom_string_data(atom_string));
 
     } else if (term_is_integer(t)) {
         avm_int_t iv = term_to_int(t);
-        fprintf(fd, AVM_INT_FMT, iv);
+        return fun->print(fun, AVM_INT_FMT, iv);
 
     } else if (term_is_nil(t)) {
-        fprintf(fd, "[]");
+        return fun->print(fun, "[]");
 
     } else if (term_is_nonempty_list(t)) {
         int is_printable = 1;
@@ -69,33 +111,55 @@ void term_fprint(FILE *fd, term t, const GlobalContext *global)
             int ok;
             char *printable = interop_list_to_string(t, &ok);
             if (LIKELY(ok)) {
-                fprintf(fd, "\"%s\"", printable);
+                int ret = fun->print(fun, "\"%s\"", printable);
                 free(printable);
+                return ret;
             } else {
-                fprintf(fd, "???");
+                return fun->print(fun, "???");
             }
 
         } else {
-            fputc('[', fd);
+            int ret = fun->print(fun, "[");
+            if (UNLIKELY(ret < 0)) {
+                return ret;
+            }
             int display_separator = 0;
             while (term_is_nonempty_list(t)) {
                 if (display_separator) {
-                    fputc(',', fd);
+                    ret += fun->print(fun, ",");
                 } else {
                     display_separator = 1;
                 }
 
-                term_fprint(fd, term_get_list_head(t), global);
+                int printed = term_funprint(fun, term_get_list_head(t), global);
+                if (UNLIKELY(printed < 0)) {
+                    return printed;
+                }
+                ret += printed;
                 t = term_get_list_tail(t);
             }
             if (!term_is_nil(t)) {
-                fputc('|', fd);
-                term_fprint(fd, t, global);
+                int printed = fun->print(fun, "|");
+                if (UNLIKELY(printed < 0)) {
+                    return printed;
+                }
+                ret += printed;
+
+                printed = term_funprint(fun, t, global);
+                if (UNLIKELY(printed < 0)) {
+                    return printed;
+                }
+                ret += printed;
+            }
+            int printed = fun->print(fun, "]");
+            if (UNLIKELY(printed < 0)) {
+                return printed;
             }
-            fputc(']', fd);
+            ret += printed;
+            return ret;
         }
     } else if (term_is_pid(t)) {
-        fprintf(fd, "<0.%i.0>", term_to_local_process_id(t));
+        return fun->print(fun, "<0.%i.0>", term_to_local_process_id(t));
 
     } else if (term_is_function(t)) {
         const term *boxed_value = term_to_const_term_ptr(t);
@@ -107,35 +171,77 @@ void term_fprint(FILE *fd, term t, const GlobalContext *global)
         #else
                 "#Fun<erl_eval.%lu.%llu>";
         #endif
-        fprintf(fd, format, fun_index, (unsigned long) fun_module);
+        return fun->print(fun, format, fun_index, (unsigned long) fun_module);
 
     } else if (term_is_tuple(t)) {
-        fputc('{', fd);
+        int ret = fun->print(fun, "{");
+        if (UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
         int tuple_size = term_get_tuple_arity(t);
         for (int i = 0; i < tuple_size; i++) {
             if (i != 0) {
-                fputc(',', fd);
+                int printed = fun->print(fun, ",");
+                if (UNLIKELY(printed < 0)) {
+                    return printed;
+                }
+                ret += printed;
+            }
+            int printed = term_funprint(fun, term_get_tuple_element(t, i), global);
+            if (UNLIKELY(printed < 0)) {
+                return printed;
             }
-            term_fprint(fd, term_get_tuple_element(t, i), global);
+            ret += printed;
         }
 
-        fputc('}', fd);
+        int printed = fun->print(fun, "}");
+        if (UNLIKELY(printed < 0)) {
+            return printed;
+        }
+        ret += printed;
+        return ret;
 
     } else if (term_is_map(t)) {
-        fprintf(fd, "#{");
+        int ret = fun->print(fun, "#{");
+        if (UNLIKELY(ret < 0)) {
+            return ret;
+        }
 
         int map_size = term_get_map_size(t);
         for (int i = 0; i < map_size; i++) {
             if (i != 0) {
-                fputc(',', fd);
+                int printed = fun->print(fun, ",");
+                if (UNLIKELY(printed < 0)) {
+                    return printed;
+                }
+                ret += printed;
+            }
+            int printed = term_funprint(fun, term_get_map_key(t, i), global);
+            if (UNLIKELY(printed < 0)) {
+                return printed;
+            }
+            ret += printed;
+
+            printed = fun->print(fun, "=>");
+            if (UNLIKELY(printed < 0)) {
+                return printed;
+            }
+            ret += printed;
+
+            printed = term_funprint(fun, term_get_map_value(t, i), global);
+            if (UNLIKELY(printed < 0)) {
+                return printed;
             }
-            term_fprint(fd, term_get_map_key(t, i), global);
-            fprintf(fd, "=>");
-            term_fprint(fd, term_get_map_value(t, i), global);
+            ret += printed;
         }
 
-        fputc('}', fd);
+        int printed = fun->print(fun, "}");
+        if (UNLIKELY(printed < 0)) {
+            return printed;
+        }
+        ret += printed;
+        return ret;
 
     } else if (term_is_binary(t)) {
         int len = term_binary_size(t);
@@ -149,24 +255,45 @@ void term_fprint(FILE *fd, term t, const GlobalContext *global)
             }
         }
 
-        fprintf(fd, "<<");
+        int ret = fun->print(fun, "<<");
+        if (UNLIKELY(ret < 0)) {
+            return ret;
+        }
+
         if (is_printable) {
-            fprintf(fd, "\"%.*s\"", len, binary_data);
+            int printed = fun->print(fun, "\"%.*s\"", len, binary_data);
+            if (UNLIKELY(printed < 0)) {
+                return printed;
+            }
+            ret += printed;
 
         } else {
             int display_separator = 0;
             for (int i = 0; i < len; i++) {
                 if (display_separator) {
-                    fputc(',', fd);
+                    int printed = fun->print(fun, ",");
+                    if (UNLIKELY(printed < 0)) {
+                        return printed;
+                    }
+                    ret += printed;
                 } else {
                     display_separator = 1;
                 }
 
                 uint8_t c = (uint8_t) binary_data[i];
-                fprintf(fd, "%i", (int) c);
+                int printed = fun->print(fun, "%i", (int) c);
+                if (UNLIKELY(printed < 0)) {
+                    return printed;
+                }
+                ret += printed;
             }
         }
-        fprintf(fd, ">>");
+        int printed = fun->print(fun, ">>");
+        if (UNLIKELY(printed < 0)) {
+            return printed;
+        }
+        ret += printed;
+        return ret;
 
     } else if (term_is_reference(t)) {
         const char *format =
@@ -175,30 +302,28 @@ void term_fprint(FILE *fd, term t, const GlobalContext *global)
 #else
         "#Ref<0.0.0.%lu>";
 #endif
-        fprintf(fd, format, term_to_ref_ticks(t));
+        return fun->print(fun, format, term_to_ref_ticks(t));
 
     } else if (term_is_boxed_integer(t)) {
         int size = term_boxed_size(t);
         switch (size) {
             case 1:
-                fprintf(fd, AVM_INT_FMT, term_unbox_int(t));
-                break;
+                return fun->print(fun, AVM_INT_FMT, term_unbox_int(t));
 
 #if BOXED_TERMS_REQUIRED_FOR_INT64 == 2
             case 2:
-                fprintf(fd, AVM_INT64_FMT, term_unbox_int64(t));
-                break;
+                return fun->print(fun, AVM_INT64_FMT, term_unbox_int64(t));
 #endif
-
             default:
                 AVM_ABORT();
         }
 
     } else if (term_is_float(t)) {
         avm_float_t f = term_to_float(t);
-        fprintf(fd, AVM_FLOAT_FMT, f);
+        return fun->print(fun, AVM_FLOAT_FMT, f);
+
     } else {
-        fprintf(fd, "Unknown term type: %" TERM_U_FMT, t);
+        return fun->print(fun, "Unknown term type: %" TERM_U_FMT, t);
     }
 }
 

src/libAtomVM/term.h

@@ -91,6 +91,15 @@ extern "C" {
 typedef struct GlobalContext GlobalContext;
 #endif
 
+typedef struct PrinterFun PrinterFun;
+
+typedef int (*printer_function_t)(PrinterFun *fun, const char *fmt, ...) PRINTF_FORMAT_ARGS(2, 3);
+
+struct PrinterFun
+{
+    printer_function_t print;
+};
+
 enum RefcBinaryFlags
 {
     RefcNoFlags = 0,
@@ -1404,15 +1413,27 @@ static inline int term_is_number(term t)
  */
 void term_display(FILE *fd, term t, const Context *ctx);
 
+/**
+ * @brief Prints a term using given printer fun
+ *
+ * @details Print any given term using a printer fun
+ * @param fd the file where the term will be printed.
+ * @param t the term that will be printed.
+ * @param global the \c GlobalContext.
+ * @returns the number of printed characters.
+ */
+int term_funprint(PrinterFun *pf, term t, const GlobalContext *global);
+
 /**
  * @brief Prints a term to the given file
  *
  * @details Print any given term to the given file.
  * @param fd the file where the term will be printed.
  * @param t the term that will be printed.
  * @param global the \c GlobalContext.
+ * @returns the number of printed characters.
  */
-void term_fprint(FILE *fd, term t, const GlobalContext *global);
+int term_fprint(FILE *fd, term t, const GlobalContext *global);
 
 /**
  * @brief Checks if a term is a string (i.e., a list of characters)

src/libAtomVM/utils.h

@@ -187,4 +187,11 @@ static inline void *rand_fail_calloc(int n, unsigned long alloc_size)
 #define AVM_ABORT() abort()
 #endif
 
+#ifdef __GNUC__
+    #define PRINTF_FORMAT_ARGS(str_pos, arg_pos) \
+        __attribute__ ((format (printf, str_pos, arg_pos)))
+#else
+    #define PRINTF_FORMAT_ARGS(...)
+#endif
+
 #endif