def write_validate_struct_item(writer, container, item, scope, parent_scope, start,
want_nw_size, want_mem_size, want_extra_size):
struct = item.type
start2 = codegen.increment_identifier(start)
scope.variable_def("SPICE_GNUC_UNUSED uint8_t *", start2 + " = %s" % (item.get_position()))
write_validate_container(writer, item.prefix, struct, start2, scope, want_nw_size, want_mem_size, want_extra_size)
def __init__(self, parent_dest, c_type, sizeof, pointer = None):
self.is_helper = False
self.reuse_scope = None
self.parent_dest = parent_dest
if parent_dest:
self.base_var = codegen.increment_identifier(parent_dest.base_var)
else:
self.base_var = "out"
self.c_type = c_type
self.sizeof = sizeof
self.pointer = pointer # None == at "end"
def __init__(self, parent_src, c_type, sizeof, pointer=None):
self.is_helper = False
self.reuse_scope = None
self.parent_src = parent_src
if parent_src:
self.base_var = codegen.increment_identifier(parent_src.base_var)
else:
self.base_var = "src"
self.c_type = c_type
self.sizeof = sizeof
self.pointer = pointer
assert pointer != None
def __init__(self, parent_src, c_type, sizeof, pointer = None):
self.is_helper = False
self.reuse_scope = None
self.parent_src = parent_src
if parent_src:
self.base_var = codegen.increment_identifier(parent_src.base_var)
else:
self.base_var = "src"
self.c_type = c_type
self.sizeof = sizeof
self.pointer = pointer
assert pointer != None
def write_validate_array_item(writer, container, item, scope, parent_scope, start,
want_nw_size, want_mem_size, want_extra_size):
array = item.type
is_byte_size = False
element_type = array.element_type
if array.is_bytes_length():
nelements = "%s__nbytes" %(item.prefix)
real_nelements = "%s__nelements" %(item.prefix)
if not parent_scope.variable_defined(real_nelements):
parent_scope.variable_def("uint32_t", real_nelements)
else:
nelements = "%s__nelements" %(item.prefix)
if not parent_scope.variable_defined(nelements):
parent_scope.variable_def("uint32_t", nelements)
if array.is_constant_length():
writer.assign(nelements, array.size)
elif array.is_remaining_length():
if element_type.is_fixed_nw_size():
if element_type.get_fixed_nw_size() == 1:
writer.assign(nelements, "message_end - %s" % item.get_position())
else:
writer.assign(nelements, "(message_end - %s) / (%s)" %(item.get_position(), element_type.get_fixed_nw_size()))
else:
raise NotImplementedError("TODO array[] of dynamic element size not done yet")
elif array.is_identifier_length():
v = write_read_primitive(writer, start, container, array.size, scope)
writer.assign(nelements, v)
elif array.is_image_size_length():
bpp = array.size[1]
width = array.size[2]
rows = array.size[3]
width_v = write_read_primitive(writer, start, container, width, scope)
rows_v = write_read_primitive(writer, start, container, rows, scope)
# TODO: Handle multiplication overflow
if bpp == 8:
writer.assign(nelements, "%s * %s" % (width_v, rows_v))
elif bpp == 1:
writer.assign(nelements, "((%s + 7) / 8 ) * %s" % (width_v, rows_v))
else:
writer.assign(nelements, "((%s * %s + 7) / 8 ) * %s" % (bpp, width_v, rows_v))
elif array.is_bytes_length():
is_byte_size = True
v = write_read_primitive(writer, start, container, array.size[1], scope)
writer.assign(nelements, v)
writer.assign(real_nelements, 0)
elif array.is_cstring_length():
writer.todo("cstring array size type not handled yet")
else:
writer.todo("array size type not handled yet")
writer.newline()
nw_size = item.nw_size()
mem_size = item.mem_size()
extra_size = item.extra_size()
if is_byte_size and want_nw_size:
writer.assign(nw_size, nelements)
want_nw_size = False
if element_type.is_fixed_nw_size() and want_nw_size:
element_size = element_type.get_fixed_nw_size()
# TODO: Overflow check the multiplication
if element_size == 1:
writer.assign(nw_size, nelements)
else:
writer.assign(nw_size, "(%s) * %s" % (element_size, nelements))
want_nw_size = False
if array.has_attr("as_ptr") and want_mem_size:
writer.assign(mem_size, "sizeof(void *)")
want_mem_size = False
if array.has_attr("chunk"):
if want_mem_size:
writer.assign(extra_size, "sizeof(SpiceChunks *)")
want_mem_size = False
if want_extra_size:
writer.assign(extra_size, "sizeof(SpiceChunks) + sizeof(SpiceChunk)")
want_extra_size = False
if element_type.is_fixed_sizeof() and want_mem_size and not is_byte_size:
# TODO: Overflow check the multiplication
if array.has_attr("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:
writer.assign(extra_size, 0)
want_extra_size = False
if not (want_mem_size or want_nw_size or want_extra_size):
return
start2 = codegen.increment_identifier(start)
scope.variable_def("uint8_t *", "%s = %s" % (start2, item.get_position()))
if is_byte_size:
start2_end = "%s_array_end" % start2
scope.variable_def("uint8_t *", start2_end)
element_item = ItemInfo(element_type, "%s__element" % item.prefix, start2)
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)
if want_extra_size:
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:
writer.assign(extra_size, 0)
want_element_nw_size = want_nw_size
if element_type.is_fixed_nw_size():
start_increment = element_type.get_fixed_nw_size()
else:
want_element_nw_size = True
start_increment = element_nw_size
if is_byte_size:
writer.assign(start2_end, "%s + %s" % (start2, nelements))
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:
if is_byte_size:
writer.increment(real_nelements, 1)
write_validate_item(writer, container, element_item, scope, parent_scope, start2,
want_element_nw_size, want_mem_size, want_extra_size)
if want_nw_size:
writer.increment(nw_size, element_nw_size)
if want_mem_size:
if array.has_attr("ptr_array"):
writer.increment(mem_size, "sizeof(void *) + SPICE_ALIGN(%s, 4)" % element_mem_size)
else:
writer.increment(mem_size, element_mem_size)
if want_extra_size:
writer.increment(extra_size, element_extra_size)
writer.increment(start2, start_increment)
if is_byte_size:
writer.error_check("%s != %s" % (start2, start2_end))
write_write_primitive(writer, start, container, array.size[1], real_nelements)
