Refactoring; added some utility functions to navigate the type definitions

src_features/signMessageEIP712/entrypoint.c

@@ -51,9 +51,242 @@ typedef enum
 uint8_t     mem_buffer[SIZE_MEM_BUFFER];
 uint16_t    mem_idx;
 
+uint8_t     *typename_matcher_array;
+uint8_t     *typenames_array;
 uint8_t     *structs_array;
 uint8_t     *current_struct_fields_array;
 
+// Typename matcher masks
+#define TYPENAME_MATCHER_ENUM(m)    ((m >> 4) & 0xF)
+#define TYPENAME_MATCHER_IDX(m)     (m & 0xF)
+
+// lib functions
+
+const uint8_t *get_array_in_mem(const uint8_t *ptr, uint8_t *const array_size)
+{
+    *array_size = *ptr;
+    return (ptr + 1);
+}
+
+static inline const uint8_t *get_string_in_mem(const uint8_t *ptr, uint8_t *const string_length)
+{
+    return get_array_in_mem(ptr, string_length);
+}
+
+// ptr must point to the beginning of a struct field
+uint8_t get_struct_field_typedesc(const uint8_t *ptr)
+{
+    return *ptr;
+}
+
+// ptr must point to the beginning of a struct field
+bool    struct_field_is_array(const uint8_t *ptr)
+{
+    return (get_struct_field_typedesc(ptr) & ARRAY_MASK);
+}
+
+// ptr must point to the beginning of a struct field
+bool    struct_field_has_typesize(const uint8_t *ptr)
+{
+    return (get_struct_field_typedesc(ptr) & TYPESIZE_MASK);
+}
+
+// ptr must point to the beginning of a struct field
+e_type  struct_field_type(const uint8_t *ptr)
+{
+    return (get_struct_field_typedesc(ptr) & TYPE_MASK);
+}
+
+// ptr must point to the beginning of a struct field
+// TODO: Extra check inside or not
+uint8_t get_struct_field_typesize(const uint8_t *ptr)
+{
+    return *(ptr + 1);
+}
+
+// ptr must point to the beginning of a struct field
+const uint8_t *get_struct_field_custom_typename(const uint8_t *ptr,
+                                                uint8_t *const length)
+{
+    ptr += 1; // skip TypeDesc
+    return get_string_in_mem(ptr, length);
+}
+
+// ptr must point to the beginning of a struct field
+const uint8_t *get_struct_field_sol_typename(const uint8_t *ptr,
+                                             uint8_t *const length)
+{
+    e_type field_type;
+
+    uint8_t matcher_count;
+    const uint8_t *matcher;
+    uint8_t matcher_idx;
+    uint8_t typenames_count;
+    const uint8_t *typename_ptr;
+
+    field_type = struct_field_type(ptr);
+    matcher = get_array_in_mem(typename_matcher_array, &matcher_count);
+    while (matcher_count-- > 0)
+    {
+        if (TYPENAME_MATCHER_ENUM(*matcher) == field_type)
+        {
+            matcher_idx = TYPENAME_MATCHER_IDX(*matcher);
+            typename_ptr = get_array_in_mem(typenames_array, &typenames_count);
+            // if the index, somehow, can't fit in the typenames array
+            if ((matcher_idx + 1) > typenames_count) return NULL;
+            while (typenames_count-- > 0)
+            {
+                typename_ptr = get_string_in_mem(typename_ptr, length);
+                if (matcher_idx-- == 0)
+                {
+                    return typename_ptr;
+                }
+                typename_ptr += *length; // skip this typename, get next one
+            }
+            return NULL; // Not found
+        }
+        matcher += 1; // get next one
+    }
+    return NULL; // Not found
+}
+
+// ptr must point to the beginning of a struct field
+const uint8_t *get_struct_field_typename(const uint8_t *ptr,
+                                         uint8_t *const length)
+{
+    if (struct_field_type(ptr) == TYPE_CUSTOM)
+    {
+        return get_struct_field_custom_typename(ptr, length);
+    }
+    return get_struct_field_sol_typename(ptr, length);
+}
+
+// ptr must point to the beginning of a depth level
+e_array_type struct_field_array_depth(const uint8_t *ptr,
+                                      uint8_t *const array_size)
+{
+    if (*ptr == ARRAY_FIXED_SIZE)
+    {
+        *array_size = *(ptr + 1);
+    }
+    return *ptr;
+}
+
+// ptr must point to the beginning of a struct field level
+const uint8_t *get_next_struct_field_array_lvl(const uint8_t *ptr)
+{
+    switch (*ptr)
+    {
+        case ARRAY_DYNAMIC:
+            break;
+        case ARRAY_FIXED_SIZE:
+            ptr += 1;
+            break;
+        default:
+            // should not be in here :^)
+            break;
+    }
+    return ptr + 1;
+}
+
+// Skips TypeDesc and TypeSize/Length+TypeName
+// Came to be since it is used in multiple functions
+// TODO: Find better name
+const uint8_t *struct_field_half_skip(const uint8_t *ptr)
+{
+    const uint8_t *field_ptr;
+    uint8_t size;
+
+    field_ptr = ptr;
+    ptr += 1; // skip TypeDesc
+    if (struct_field_type(field_ptr) == TYPE_CUSTOM)
+    {
+        get_string_in_mem(ptr, &size);
+        ptr += (1 + size); // skip typename
+    }
+    else if (struct_field_has_typesize(field_ptr))
+    {
+        ptr += 1; // skip TypeSize
+    }
+    return ptr;
+}
+
+// ptr must point to the beginning of a struct field
+const uint8_t *get_struct_field_array_lvls_array(const uint8_t *ptr,
+                                                 uint8_t *const length)
+{
+    ptr = struct_field_half_skip(ptr);
+    return get_array_in_mem(ptr, length);
+}
+
+// ptr must point to the beginning of a struct field
+const uint8_t *get_struct_field_keyname(const uint8_t *ptr,
+                                        uint8_t *const length)
+{
+    const uint8_t *field_ptr;
+    uint8_t size;
+
+    field_ptr = ptr;
+    ptr = struct_field_half_skip(ptr);
+    if (struct_field_is_array(field_ptr))
+    {
+        ptr = get_array_in_mem(ptr, &size);
+        while (size-- > 0)
+        {
+            ptr = get_next_struct_field_array_lvl(ptr);
+        }
+    }
+    return get_string_in_mem(ptr, length);
+}
+
+// ptr must point to the beginning of a struct field
+const uint8_t *get_next_struct_field(const uint8_t *ptr)
+{
+    uint8_t length;
+
+    ptr = get_struct_field_keyname(ptr, &length);
+    return (ptr + length);
+}
+
+// ptr must point to the beginning of a struct
+const uint8_t *get_struct_name(const uint8_t *ptr, uint8_t *const length)
+{
+    return get_string_in_mem(ptr, length);
+}
+
+// ptr must point to the beginning of a struct
+const uint8_t *get_struct_fields_array(const uint8_t *ptr,
+                                       uint8_t *const length)
+{
+    uint8_t name_length;
+
+    get_struct_name(ptr, &name_length);
+    ptr += (1 + name_length); // skip length
+    return get_array_in_mem(ptr, length);
+}
+
+// ptr must point to the beginning of a struct
+const uint8_t *get_next_struct(const uint8_t *ptr)
+{
+    uint8_t fields_count;
+
+    ptr = get_struct_fields_array(ptr, &fields_count);
+    while (fields_count-- > 0)
+    {
+        ptr = get_next_struct_field(ptr);
+    }
+    return ptr;
+}
+
+// ptr must point to the size of the structs array
+const uint8_t *get_structs_array(const uint8_t *ptr, uint8_t *const length)
+{
+    return get_array_in_mem(ptr, length);
+}
+//
+
+
+
 
 
 bool    set_struct_name(uint8_t *data)
@@ -133,99 +366,85 @@ bool    set_struct_field(uint8_t *data)
     return true;
 }
 
+
 void    dump_mem(void)
 {
-    uint8_t *mem = structs_array + 1;
+    uint8_t structs_count;
-    uint8_t type_desc;
+    const uint8_t *struct_ptr;
+    //
     uint8_t fields_count;
-    uint8_t array_depth;
+    const uint8_t *field_ptr;
+    //
+    uint8_t lvls_count;
+    const uint8_t *lvl_ptr;
 
-    for (int i = 0; i < *structs_array; ++i)
+    const uint8_t *name;
+    uint8_t name_length;
+    //
+    uint8_t array_size;
+    uint8_t byte_size;
+
+
+    struct_ptr = get_structs_array(structs_array, &structs_count);
+    while (structs_count-- > 0)
     {
-        fwrite(mem + 1, *mem, sizeof(*mem), stdout);
+        name = get_struct_name(struct_ptr, &name_length);
+        fwrite(name, sizeof(*name), name_length, stdout);
         printf("(");
-        mem += (1 + *mem);
+        field_ptr = get_struct_fields_array(struct_ptr, &fields_count);
-        fields_count = *mem;
+        for (int idx = 0; idx < fields_count; ++idx)
-        mem += 1;
-        for (int y = 0; y < fields_count; ++y)
         {
-            if (y > 0) printf(",");
+            if (idx > 0) printf(",");
-            type_desc = *mem;
+            name = get_struct_field_typename(field_ptr, &name_length);
-            mem += 1;
+            fwrite(name, sizeof(*name), name_length, stdout);
-            switch (type_desc & TYPE_MASK)
+            if (struct_field_has_typesize(field_ptr))
             {
-                case TYPE_CUSTOM:
+                byte_size = get_struct_field_typesize(field_ptr);
-                    fwrite(mem + 1, *mem, sizeof(*mem), stdout);
+                switch(struct_field_type(field_ptr))
-                    mem += (1 + *mem);
-                    if (type_desc & TYPESIZE_MASK) mem += 1;
-                    break;
-                case TYPE_SOL_UINT:
-                    printf("u");
-                case TYPE_SOL_INT:
-                    printf("int");
-                    if (type_desc & TYPESIZE_MASK)
-                    {
-                        printf("%d", (*mem * 8));
-                        mem += 1;
-                    }
-                    break;
-                case TYPE_SOL_ADDRESS:
-                    printf("address");
-                    if (type_desc & TYPESIZE_MASK) mem += 1;
-                    break;
-                case TYPE_SOL_BOOL:
-                    printf("bool");
-                    if (type_desc & TYPESIZE_MASK) mem += 1;
-                    break;
-                case TYPE_SOL_STRING:
-                    printf("string");
-                    if (type_desc & TYPESIZE_MASK) mem += 1;
-                    break;
-                case TYPE_SOL_BYTE:
-                    printf("byte");
-                    if (type_desc & TYPESIZE_MASK) mem += 1;
-                    break;
-                case TYPE_SOL_BYTES_FIX:
-                    printf("bytes");
-                    if (type_desc & TYPESIZE_MASK)
-                    {
-                        printf("%d", *mem);
-                        mem += 1;
-                    }
-                    break;
-                case TYPE_SOL_BYTES_DYN:
-                    printf("bytes");
-                    if (type_desc & TYPESIZE_MASK) mem += 1;
-                    break;
-                default:
-                    // should not be in here :^)
-                    break;
-            }
-            if (type_desc & ARRAY_MASK)
-            {
-                array_depth = *mem++;
-                while (array_depth-- > 0)
                 {
-                    switch (*mem++)
+                    case TYPE_SOL_INT:
+                    case TYPE_SOL_UINT:
+                        printf("%u", (byte_size * 8));
+                        break;
+                    case TYPE_SOL_BYTES_FIX:
+                        printf("%u", byte_size);
+                        break;
+                    default:
+                        // should not be in here :^)
+                        break;
+                }
+            }
+            if (struct_field_is_array(field_ptr))
+            {
+                lvl_ptr = get_struct_field_array_lvls_array(field_ptr, &lvls_count);
+                while (lvls_count-- > 0)
+                {
+                    printf("[");
+                    switch (struct_field_array_depth(lvl_ptr, &array_size))
                     {
                         case ARRAY_DYNAMIC:
-                            printf("[]");
                             break;
                         case ARRAY_FIXED_SIZE:
-                            printf("[%u]", *mem++);
+                            printf("%u", array_size);
                             break;
                         default:
                             // should not be in here :^)
                             break;
                     }
+                    printf("]");
+                    lvl_ptr = get_next_struct_field_array_lvl(lvl_ptr);
                 }
             }
             printf(" ");
-            fwrite(mem + 1, *mem, sizeof(*mem), stdout);
+            name = get_struct_field_keyname(field_ptr, &name_length);
-            mem += (1 + *mem);
+            fwrite(name, sizeof(*name), name_length, stdout);
+
+            field_ptr = get_next_struct_field(field_ptr);
         }
         printf(")\n");
+        struct_ptr = get_next_struct(struct_ptr);
     }
+    return;
 }
 
 bool    handle_apdu(uint8_t *data)
@@ -255,11 +474,62 @@ bool    handle_apdu(uint8_t *data)
     return true;
 }
 
+bool    init_typenames(void)
+{
+    char    *typenames_str[] = {
+        "int",
+        "uint",
+        "address",
+        "bool",
+        "string",
+        "byte",
+        "bytes"
+    };
+    // table to match type enums to indexes in the typenames string array
+    int     enum_to_str[][2] = {
+        { TYPE_SOL_INT, 0 },
+        { TYPE_SOL_UINT, 1},
+        { TYPE_SOL_ADDRESS, 2 },
+        { TYPE_SOL_BOOL, 3 },
+        { TYPE_SOL_STRING, 4 },
+        { TYPE_SOL_BYTE, 5 },
+        { TYPE_SOL_BYTES_FIX, 6 },
+        { TYPE_SOL_BYTES_DYN, 6 }
+    };
+
+    typename_matcher_array = &mem_buffer[mem_idx++];
+    *typename_matcher_array = 0;
+    // set matchers
+    for (size_t i = 0; i < (sizeof(enum_to_str) / sizeof(enum_to_str[0])); ++i)
+    {
+        mem_buffer[mem_idx++] = ((enum_to_str[i][0] << 4) | (enum_to_str[i][1]));
+        // increment array size
+        *typename_matcher_array += 1;
+    }
+
+    typenames_array = &mem_buffer[mem_idx++];
+    *typenames_array = 0;
+    // set typenames
+    for (size_t i = 0; i < (sizeof(typenames_str) / sizeof(typenames_str[0])); ++i)
+    {
+        mem_buffer[mem_idx++] = strlen(typenames_str[i]); // length
+        // copy typename
+        memcpy(&mem_buffer[mem_idx], typenames_str[i], mem_buffer[mem_idx - 1]);
+        // increment mem idx by typename length
+        mem_idx += mem_buffer[mem_idx - 1];
+        // increment array size
+        *typenames_array += 1;
+    }
+    return true;
+}
+
 void    init_heap(void)
 {
     // init global variables
     mem_idx = 0;
 
+    init_typenames();
+
     // set types pointer
     structs_array = &mem_buffer[mem_idx];