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)