Remove duplicated code for UTF-8 validation

There was some code duplicated for validating UTF-8 strings, that was
even performing full decode. Use instead new `unicode_is_valid_utf8_buf`
function that is also based on highly optimized code.

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

Author: bettio

src/libAtomVM/bif.c

@@ -1638,19 +1638,10 @@ term binary_to_atom(Context *ctx, term a_binary, term encoding, bool create_new,
 
     AtomString atom;
     if (LIKELY(!encode_latin1_to_utf8)) {
-        size_t i = 0;
-        while (i < atom_string_len) {
-            uint32_t codepoint;
-            size_t codepoint_size;
-            if (UNLIKELY(bitstring_utf8_decode(
-                    (uint8_t *) atom_string + i, atom_string_len, &codepoint, &codepoint_size))
-                != UnicodeTransformDecodeSuccess) {
-                *error_reason = BADARG_ATOM;
-                return term_invalid_term();
-            }
-            i += codepoint_size;
+        if (UNLIKELY(!unicode_is_valid_utf8_buf((const uint8_t *) atom_string, atom_string_len))) {
+            *error_reason = BADARG_ATOM;
+            return term_invalid_term();
         }
-
         atom = malloc(atom_string_len + 1);
         if (IS_NULL_PTR(atom)) {
             *error_reason = OUT_OF_MEMORY_ATOM;

src/libAtomVM/externalterm.c

@@ -636,17 +636,8 @@ static term parse_external_terms(const uint8_t *external_term_buf, size_t *eterm
             uint8_t atom_len = *(external_term_buf + 1);
             const uint8_t *atom_chars = external_term_buf + 2;
 
-            size_t remaining_length = atom_len;
-            const uint8_t *curr_buf = atom_chars;
-            while (remaining_length) {
-                uint32_t out_c;
-                size_t codepoint_size;
-                enum UnicodeTransformDecodeResult result = bitstring_utf8_decode(curr_buf, remaining_length, &out_c, &codepoint_size);
-                if (UNLIKELY(result != UnicodeTransformDecodeSuccess)) {
-                    return term_invalid_term();
-                }
-                remaining_length -= codepoint_size;
-                curr_buf += codepoint_size;
+            if (UNLIKELY(!unicode_is_valid_utf8_buf((const uint8_t *) atom_chars, atom_len))) {
+                return term_invalid_term();
             }
 
             // AtomString first byte is the atom length

src/libAtomVM/unicode.c

@@ -53,8 +53,8 @@ static const uint8_t utf8d[] = {
   12,36,12,12,12,12,12,12,12,12,12,12,
 };
 
-uint32_t inline
-decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
+static inline uint32_t decode(uint32_t* state, uint32_t* codep, uint32_t byte)
+{
   uint32_t type = utf8d[byte];
 
   *codep = (*state != UTF8_ACCEPT) ?
@@ -67,6 +67,18 @@ decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
 
 // clang-format on
 
+bool unicode_is_valid_utf8_buf(const uint8_t *buf, size_t len)
+{
+    uint32_t codepoint = 0;
+    uint32_t state = 0;
+
+    for (size_t i = 0; i < len; i++) {
+        state = decode(&state, &codepoint, buf[i]);
+    }
+
+    return state == UTF8_ACCEPT;
+}
+
 size_t unicode_buf_utf8_len(const uint8_t *buf, size_t buf_len)
 {
     size_t count = 0;

src/libAtomVM/unicode.h

@@ -40,6 +40,8 @@ static inline bool unicode_is_valid_codepoint(uint32_t codepoint)
     return (codepoint < 0x110000) && !((codepoint > 0xD800) && (codepoint < 0xDFFF));
 }
 
+bool unicode_is_valid_utf8_buf(const uint8_t *buf, size_t len);
+
 #ifdef __cplusplus
 }
 #endif