Properly parse and marshall SpiceString

1 files changed, 37 insertions, 7 deletions

diff --git a/python_modules/demarshal.py b/python_modules/demarshal.py
index 023c3f60..4d3e79b3 100644
--- a/python_modules/demarshal.py
+++ b/python_modules/demarshal.py
@@ -125,7 +125,7 @@ def write_validate_switch_member(writer, container, switch_member, scope, parent
             item.subprefix = item.prefix + "_" + m.name
             item.non_null = c.member.has_attr("nonnull")
             sub_want_extra_size = want_extra_size
-            if sub_want_extra_size and not m.contains_extra_size():
+            if sub_want_extra_size and not m.contains_extra_size() and not m.is_extra_size():
                 writer.assign(item.extra_size(), 0)
                 sub_want_extra_size = False
 
@@ -309,10 +309,13 @@ def write_validate_array_item(writer, container, item, scope, parent_scope, star
 
     if element_type.is_fixed_sizeof() and want_mem_size and not is_byte_size:
         # TODO: Overflow check the multiplication
-        writer.assign(mem_size, "%s * %s" % (element_type.sizeof(), nelements))
+        if array.ptr_array:
+            writer.assign(mem_size, "sizeof(void *) + SPICE_ALIGN(%s * %s, 4)" % (element_type.sizeof(), nelements))
+        else:
+            writer.assign(mem_size, "%s * %s" % (element_type.sizeof(), nelements))
         want_mem_size = False
 
-    if not element_type.contains_extra_size() and want_extra_size:
+    if not element_type.contains_extra_size() and not array.is_extra_size() and want_extra_size:
         writer.assign(extra_size, 0)
         want_extra_size = False
 
@@ -329,14 +332,24 @@ def write_validate_array_item(writer, container, item, scope, parent_scope, star
 
     element_nw_size = element_item.nw_size()
     element_mem_size = element_item.mem_size()
+    element_extra_size = element_item.extra_size()
     scope.variable_def("uint32_t", element_nw_size)
     scope.variable_def("uint32_t", element_mem_size)
+    want_is_extra_size = False
+    want_element_mem_size = want_mem_size
+    if want_extra_size:
+        if array.is_extra_size():
+            want_is_extra_size = True
+            want_extra_size = False
+            want_element_mem_size = True
+        else:
+            scope.variable_def("uint32_t", element_extra_size)
 
     if want_nw_size:
         writer.assign(nw_size, 0)
     if want_mem_size:
         writer.assign(mem_size, 0)
-    if want_extra_size:
+    if want_extra_size or want_is_extra_size:
         writer.assign(extra_size, 0)
 
     want_element_nw_size = want_nw_size
@@ -352,13 +365,19 @@ def write_validate_array_item(writer, container, item, scope, parent_scope, star
     with writer.index(no_block = is_byte_size) as index:
         with writer.while_loop("%s < %s" % (start2, start2_end) ) if is_byte_size else writer.for_loop(index, nelements) as scope:
             write_validate_item(writer, container, element_item, scope, parent_scope, start2,
-                                want_element_nw_size, want_mem_size, want_extra_size)
+                                want_element_nw_size, want_element_mem_size, want_extra_size)
 
             if want_nw_size:
                 writer.increment(nw_size, element_nw_size)
             if want_mem_size:
-                writer.increment(mem_size, element_mem_size)
-            if want_extra_size:
+                if not array.is_extra_size():
+                    writer.increment(mem_size, element_mem_size)
+            if want_is_extra_size:
+                if array.ptr_array:
+                    writer.increment(extra_size, "sizeof(void *) + SPICE_ALIGN(%s, 4)" % element_mem_size)
+                else:
+                    writer.increment(extra_size, "%s + %s" % (element_mem_size, element_extra_size))
+            elif want_extra_size:
                 writer.increment(extra_size, element_extra_size)
 
             writer.increment(start2, start_increment)
@@ -722,8 +741,16 @@ def write_array_parser(writer, nelements, array, dest, scope):
             scope.variable_def("uint32_t", real_nelements)
             writer.assign("array_end", "end + %s" % nelements)
             writer.assign(real_nelements, 0)
+        if array.ptr_array:
+            scope.variable_def("void **", "ptr_array")
+            scope.variable_def("int", "ptr_array_index")
+            writer.assign("ptr_array_index", 0)
+            writer.assign("ptr_array", "(void **)end")
+            writer.increment("end", "sizeof(void *) * %s" % nelements)
         with writer.index(no_block = is_byte_size) as index:
             with writer.while_loop("end < array_end") if is_byte_size else writer.for_loop(index, nelements) as array_scope:
+                if array.ptr_array:
+                    writer.statement("ptr_array[ptr_array_index++] = end")
                 if is_byte_size:
                     writer.increment(real_nelements, 1)
                 if element_type.is_primitive():
@@ -733,6 +760,9 @@ def write_array_parser(writer, nelements, array, dest, scope):
                     dest2 = dest.child_at_end(writer, element_type)
                     dest2.reuse_scope = array_scope
                     write_container_parser(writer, element_type, dest2)
+                if array.ptr_array:
+                    writer.comment("Align ptr_array element to 4 bytes").newline()
+                    writer.assign("end", "(uint8_t *)SPICE_ALIGN((size_t)end, 4)")
         if is_byte_size:
             writer.assign(dest.get_ref(array.size[2]), real_nelements)