#include "typegen.h"
#include "expr.h"
+/* round size up to multiple of alignment */
+#define ROUND_SIZE(size, alignment) (((size) + ((alignment) - 1)) & ~((alignment) - 1))
+/* value to add on to round size up to a multiple of alignment */
+#define ROUNDING(size, alignment) (((alignment) - 1) - (((size) + ((alignment) - 1)) & ((alignment) - 1)))
+
static const func_t *current_func;
static const type_t *current_structure;
static const type_t *current_iface;
*align = falign;
have_align = TRUE;
}
- size = (size + (falign - 1)) & ~(falign - 1);
+ size = ROUND_SIZE(size, falign);
size += fsize;
}
- size = (size + (*align - 1)) & ~(*align - 1);
+ size = ROUND_SIZE(size, *align);
return size;
}
size_t size = type_memsize(ft, &align);
if (salign == -1)
salign = align;
- offset = (offset + (align - 1)) & ~(align - 1);
+ offset = ROUND_SIZE(offset, align);
offset += size;
}
- return ((offset + (salign - 1)) & ~(salign - 1)) - offset;
+ return ROUNDING(offset, salign);
}
size_t type_memsize(const type_t *t, unsigned int *align)
{
size_t size = 0;
- if (t->declarray && is_conformant_array(t))
+ if (t->kind == TKIND_ALIAS)
+ size = type_memsize(t->orig, align);
+ else if (t->declarray && is_conformant_array(t))
{
type_memsize(t->ref, align);
size = 0;
}
else if (is_ptr(t) || is_conformant_array(t))
{
- size = sizeof(void *);
+#if defined(TARGET_i386)
+ size = 4;
+#elif defined(TARGET_amd64)
+ size = 8;
+#else
+#error Unsupported CPU
+#endif
if (size > *align) *align = size;
}
else switch (t->type)
{
unsigned int start, absoff, flags;
unsigned int align = 0, ualign = 0;
- const char *name;
+ const char *name = NULL;
type_t *utype = get_user_type(type, &name);
size_t usize = user_type_has_variable_size(utype) ? 0 : type_memsize(utype, &ualign);
size_t size = type_memsize(type, &align);
if (is_ptr(type) || (!type->declarray && is_conformant_array(type)))
{
+ size_t memsize;
+
print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", RPC_FC_NO_REPEAT);
print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD);
}
align = 0;
- *offset_in_memory += type_memsize(type, &align);
- /* FIXME: is there a case where these two are different? */
- align = 0;
- *offset_in_buffer += type_memsize(type, &align);
+ memsize = type_memsize(type, &align);
+ *offset_in_memory += memsize;
+ /* increment these separately as in the case of conformant (varying)
+ * structures these start at different values */
+ *offset_in_buffer += memsize;
return 1;
}
{
const var_t *v;
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
+ {
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t padding;
+ align = 0;
+ type_memsize(v->type, &align);
+ padding = ROUNDING(*offset_in_memory, align);
+ *offset_in_memory += padding;
+ *offset_in_buffer += padding;
+ }
written += write_no_repeat_pointer_descriptions(
file, v->type,
offset_in_memory, offset_in_buffer, typestring_offset);
+ }
}
else
{
+ size_t memsize;
align = 0;
- *offset_in_memory += type_memsize(type, &align);
- /* FIXME: is there a case where these two are different? */
- align = 0;
- *offset_in_buffer += type_memsize(type, &align);
+ memsize = type_memsize(type, &align);
+ *offset_in_memory += memsize;
+ /* increment these separately as in the case of conformant (varying)
+ * structures these start at different values */
+ *offset_in_buffer += memsize;
}
return written;
{
if (offset_in_memory && offset_in_buffer)
{
+ size_t memsize;
+
/* pointer instance */
/* FIXME: sometimes from end of structure, sometimes from beginning */
print_file(file, 2, "NdrFcShort(0x%x), /* Memory offset = %d */\n", *offset_in_memory, *offset_in_memory);
print_file(file, 2, "NdrFcShort(0x%x), /* Buffer offset = %d */\n", *offset_in_buffer, *offset_in_buffer);
align = 0;
- *offset_in_memory += type_memsize(type, &align);
- /* FIXME: is there a case where these two are different? */
- align = 0;
- *offset_in_buffer += type_memsize(type, &align);
+ memsize = type_memsize(type, &align);
+ *offset_in_memory += memsize;
+ /* increment these separately as in the case of conformant (varying)
+ * structures these start at different values */
+ *offset_in_buffer += memsize;
}
*typestring_offset += 4;
{
return write_pointer_description_offsets(
file, attrs, type->ref, offset_in_memory, offset_in_buffer,
- typestring_offset);
+ typestring_offset);
}
else if (is_non_complex_struct(type))
{
const var_t *v;
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
{
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t padding;
+ align = 0;
+ type_memsize(v->type, &align);
+ padding = ROUNDING(*offset_in_memory, align);
+ *offset_in_memory += padding;
+ *offset_in_buffer += padding;
+ }
written += write_pointer_description_offsets(
file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
typestring_offset);
}
else
{
- align = 0;
- if (offset_in_memory)
- *offset_in_memory += type_memsize(type, &align);
- /* FIXME: is there a case where these two are different? */
- align = 0;
- if (offset_in_buffer)
- *offset_in_buffer += type_memsize(type, &align);
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t memsize;
+ align = 0;
+ memsize = type_memsize(type, &align);
+ *offset_in_memory += memsize;
+ /* increment these separately as in the case of conformant (varying)
+ * structures these start at different values */
+ *offset_in_buffer += memsize;
+ }
}
return written;
const var_t *v;
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
{
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t padding;
+ align = 0;
+ type_memsize(v->type, &align);
+ padding = ROUNDING(*offset_in_memory, align);
+ *offset_in_memory += padding;
+ *offset_in_buffer += padding;
+ }
pointer_count += write_fixed_array_pointer_descriptions(
file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
typestring_offset);
}
else
{
- align = 0;
- if (offset_in_memory)
- *offset_in_memory += type_memsize(type, &align);
- /* FIXME: is there a case where these two are different? */
- align = 0;
- if (offset_in_buffer)
- *offset_in_buffer += type_memsize(type, &align);
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t memsize;
+ align = 0;
+ memsize = type_memsize(type, &align);
+ *offset_in_memory += memsize;
+ /* increment these separately as in the case of conformant (varying)
+ * structures these start at different values */
+ *offset_in_buffer += memsize;
+ }
}
return pointer_count;
unsigned int align;
int pointer_count = 0;
- /* FIXME: do varying array searching here, but pointer searching in write_pointer_description_offsets */
-
if (is_array(type) && type->length_is)
{
unsigned int temp = 0;
if (pointer_count > 0)
{
unsigned int increment_size;
- size_t offset_of_array_pointer_mem = 0;
- size_t offset_of_array_pointer_buf = 0;
align = 0;
increment_size = type_memsize(type->ref, &align);
*typestring_offset += 8;
pointer_count = write_pointer_description_offsets(
- file, attrs, type, &offset_of_array_pointer_mem,
- &offset_of_array_pointer_buf, typestring_offset);
+ file, attrs, type, offset_in_memory,
+ offset_in_buffer, typestring_offset);
}
}
else if (is_struct(type->type))
const var_t *v;
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
{
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t padding;
+
+ if (is_array(v->type) && v->type->length_is)
+ {
+ *offset_in_buffer = ROUND_SIZE(*offset_in_buffer, 4);
+ /* skip over variance and offset in buffer */
+ *offset_in_buffer += 8;
+ }
+
+ align = 0;
+ type_memsize(v->type, &align);
+ padding = ROUNDING(*offset_in_memory, align);
+ *offset_in_memory += padding;
+ *offset_in_buffer += padding;
+ }
pointer_count += write_varying_array_pointer_descriptions(
file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
typestring_offset);
}
else
{
- align = 0;
- if (offset_in_memory)
- *offset_in_memory += type_memsize(type, &align);
- /* FIXME: is there a case where these two are different? */
- align = 0;
- if (offset_in_buffer)
- *offset_in_buffer += type_memsize(type, &align);
+ if (offset_in_memory && offset_in_buffer)
+ {
+ size_t memsize;
+ align = 0;
+ memsize = type_memsize(type, &align);
+ *offset_in_memory += memsize;
+ /* increment these separately as in the case of conformant (varying)
+ * structures these start at different values */
+ *offset_in_buffer += memsize;
+ }
}
return pointer_count;
typestring_offset);
}
- /* pass 4: search for pointers in varying arrays */
+ /* pass 4: search for pointers in varying arrays */
offset_in_memory = 0;
offset_in_buffer = 0;
write_varying_array_pointer_descriptions(
error("write_struct_members: cannot align type %d\n", ft->type);
}
print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
- offset = (offset + (align - 1)) & ~(align - 1);
+ offset = ROUND_SIZE(offset, align);
*typestring_offset += 1;
}
write_member_type(file, type, field->attrs, field->type, corroff,
}
}
- padding = ((offset + (salign - 1)) & ~(salign - 1)) - offset;
+ padding = ROUNDING(offset, salign);
if (padding)
{
print_file(file, 2, "0x%x,\t/* FC_STRUCTPAD%d */\n",
error("union switch type must be an integer, char, or enum\n");
}
}
+ else if (is_attr(type->attrs, ATTR_SWITCHTYPE))
+ {
+ static const expr_t dummy_expr; /* FIXME */
+ const type_t *st = get_attrp(type->attrs, ATTR_SWITCHTYPE);
+
+ switch (st->type)
+ {
+ case RPC_FC_CHAR:
+ case RPC_FC_SMALL:
+ case RPC_FC_USMALL:
+ case RPC_FC_SHORT:
+ case RPC_FC_USHORT:
+ case RPC_FC_LONG:
+ case RPC_FC_ULONG:
+ case RPC_FC_ENUM16:
+ case RPC_FC_ENUM32:
+ print_file(file, 2, "0x%x,\t/* %s */\n", type->type, string_of_type(type->type));
+ print_file(file, 2, "0x%x,\t/* Switch type= %s */\n",
+ st->type, string_of_type(st->type));
+ *tfsoff += 2;
+ break;
+ default:
+ error("union switch type must be an integer, char, or enum\n");
+ }
+
+ *tfsoff += write_conf_or_var_desc(file, NULL, *tfsoff, st, &dummy_expr );
+ }
+
print_file(file, 2, "NdrFcShort(0x%x),\t/* %d */\n", size, size);
print_file(file, 2, "NdrFcShort(0x%x),\t/* %d */\n", nbranch, nbranch);
*tfsoff += 4;
static unsigned int get_required_buffer_size_type(
const type_t *type, const char *name, unsigned int *alignment)
{
+ const char *uname;
+ const type_t *utype;
+
*alignment = 0;
- if (is_user_type(type))
+ if ((utype = get_user_type(type, &uname)))
{
- const char *uname;
- const type_t *utype = get_user_type(type, &uname);
return get_required_buffer_size_type(utype, uname, alignment);
}
else
}
if (phase == PHASE_MARSHAL)
- print_file(file, indent, "MIDL_memset(_StubMsg.Buffer, 0, (0x%x - (long)_StubMsg.Buffer) & 0x%x);\n", alignment, alignment - 1);
- print_file(file, indent, "_StubMsg.Buffer = (unsigned char *)(((long)_StubMsg.Buffer + %u) & ~0x%x);\n",
+ print_file(file, indent, "MIDL_memset(_StubMsg.Buffer, 0, (0x%x - (size_t)_StubMsg.Buffer) & 0x%x);\n", alignment, alignment - 1);
+ print_file(file, indent, "_StubMsg.Buffer = (unsigned char *)(((size_t)_StubMsg.Buffer + %u) & ~0x%x);\n",
alignment - 1, alignment - 1);
if (phase == PHASE_MARSHAL)
/* returns whether the MaxCount, Offset or ActualCount members need to be
* filled in for the specified phase */
-static inline int is_size_needed_for_phase(enum remoting_phase phase)
+static inline int is_conformance_needed_for_phase(enum remoting_phase phase)
{
return (phase != PHASE_UNMARSHAL);
}
return x;
}
+static void write_parameter_conf_or_var_exprs(FILE *file, int indent,
+ enum remoting_phase phase,
+ const var_t *var)
+{
+ const type_t *type = var->type;
+ /* get fundamental type for the argument */
+ for (;;)
+ {
+ if (is_attr(type->attrs, ATTR_WIREMARSHAL))
+ break;
+ else if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
+ break;
+ else if (is_array(type) || is_string_type(var->attrs, type))
+ {
+ if (is_conformance_needed_for_phase(phase))
+ {
+ if (type->size_is)
+ {
+ print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
+ write_expr(file, type->size_is, 1, 1, NULL, NULL);
+ fprintf(file, ";\n\n");
+ }
+ if (type->length_is)
+ {
+ print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
+ print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
+ write_expr(file, type->length_is, 1, 1, NULL, NULL);
+ fprintf(file, ";\n\n");
+ }
+ }
+ break;
+ }
+ else if (type->type == RPC_FC_NON_ENCAPSULATED_UNION)
+ {
+ if (is_conformance_needed_for_phase(phase))
+ {
+ print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
+ write_expr(file, get_attrp(var->attrs, ATTR_SWITCHIS), 1, 1, NULL, NULL);
+ fprintf(file, ";\n\n");
+ }
+ break;
+ }
+ else if (type->type == RPC_FC_IP)
+ {
+ expr_t *iid;
+
+ if (is_conformance_needed_for_phase(phase) && (iid = get_attrp( var->attrs, ATTR_IIDIS )))
+ {
+ print_file( file, indent, "_StubMsg.MaxCount = (unsigned long) " );
+ write_expr( file, iid, 1, 1, NULL, NULL );
+ fprintf( file, ";\n\n" );
+ }
+ break;
+ }
+ else if (is_ptr(type))
+ type = type->ref;
+ else
+ break;
+ }
+}
+
static void write_remoting_arg(FILE *file, int indent, const func_t *func,
enum pass pass, enum remoting_phase phase,
const var_t *var)
break;
}
+ write_parameter_conf_or_var_exprs(file, indent, phase, var);
rtype = type->type;
if (is_context_handle(type))
print_phase_function(file, indent, "NonConformantString", phase, var, start_offset);
else
{
- if (type->size_is && is_size_needed_for_phase(phase))
- {
- print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
- write_expr(file, type->size_is, 1, 1, NULL, NULL);
- fprintf(file, ";\n");
- }
-
if (phase == PHASE_FREE || pass == PASS_RETURN || pointer_type == RPC_FC_UP)
print_phase_function(file, indent, "Pointer", phase, var,
start_offset - (type->size_is ? 4 : 2));
if (tc == RPC_FC_SMVARRAY || tc == RPC_FC_LGVARRAY)
{
- if (is_size_needed_for_phase(phase))
- {
- print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
- print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
- write_expr(file, type->length_is, 1, 1, NULL, NULL);
- fprintf(file, ";\n\n");
- }
array_type = "VaryingArray";
}
else if (tc == RPC_FC_CARRAY)
{
- if (is_size_needed_for_phase(phase))
- {
- print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
- write_expr(file, type->size_is, 1, 1, NULL, NULL);
- fprintf(file, ";\n\n");
- }
array_type = "ConformantArray";
}
else if (tc == RPC_FC_CVARRAY || tc == RPC_FC_BOGUS_ARRAY)
{
- if (is_size_needed_for_phase(phase))
- {
- if (type->size_is)
- {
- print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
- write_expr(file, type->size_is, 1, 1, NULL, NULL);
- fprintf(file, ";\n");
- }
- if (type->length_is)
- {
- print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
- print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
- write_expr(file, type->length_is, 1, 1, NULL, NULL);
- fprintf(file, ";\n\n");
- }
- }
array_type = (tc == RPC_FC_BOGUS_ARRAY
? "ComplexArray"
: "ConformantVaryingArray");
}
else
{
- expr_t *iid;
- expr_t *sx = get_size_is_expr(type, var->name);
-
- if ((iid = get_attrp( var->attrs, ATTR_IIDIS )))
- {
- print_file( file, indent, "_StubMsg.MaxCount = (unsigned long) " );
- write_expr( file, iid, 1, 1, NULL, NULL );
- fprintf( file, ";\n\n" );
- }
- else if (sx)
- {
- print_file(file, indent, "_StubMsg.MaxCount = (unsigned long) ");
- write_expr(file, sx, 1, 1, NULL, NULL);
- fprintf(file, ";\n\n");
- }
if (var->type->ref->type == RPC_FC_IP)
print_phase_function(file, indent, "InterfacePointer", phase, var, start_offset);
else
size += get_size_procformatstring(stmt->u.lib->stmts, pred) - 1;
continue;
}
- else if (stmt->type != STMT_TYPE && stmt->u.type->type != RPC_FC_IP)
+ else if (stmt->type != STMT_TYPE || stmt->u.type->type != RPC_FC_IP)
continue;
iface = stmt->u.type;
write_type_decl_left(file, var->type);
fprintf(file, " ");
if (var->type->declarray) {
- fprintf(file, "( *");
- write_name(file, var);
- fprintf(file, " )");
+ fprintf(file, "(*%s)", get_name(var));
} else
- write_name(file, var);
+ fprintf(file, "%s", get_name(var));
write_type_right(file, var->type, FALSE);
fprintf(file, ";\n");
if (!in_attr)
{
- print_file(file, indent, "");
- write_name(file, var);
+ print_file(file, indent, "%s", get_name(var));
if (is_context_handle(var->type))
{
projects / reactos.git / blobdiff