2 * Format String Generator for IDL Compiler
4 * Copyright 2005-2006 Eric Kohl
5 * Copyright 2005-2006 Robert Shearman
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
41 #include "wine/list.h"
46 static const func_t
*current_func
;
47 static const type_t
*current_structure
;
49 /* name of the structure variable for structure callbacks */
50 #define STRUCT_EXPR_EVAL_VAR "pS"
52 static struct list expr_eval_routines
= LIST_INIT(expr_eval_routines
);
54 struct expr_eval_routine
57 const type_t
*structure
;
58 size_t structure_size
;
62 static size_t type_memsize(const type_t
*t
, int ptr_level
, const array_dims_t
*array
);
63 static size_t fields_memsize(const var_list_t
*fields
);
65 static int compare_expr(const expr_t
*a
, const expr_t
*b
)
69 if (a
->type
!= b
->type
)
70 return a
->type
- b
->type
;
77 return a
->u
.lval
- b
->u
.lval
;
79 return strcmp(a
->u
.sval
, b
->u
.sval
);
81 ret
= compare_expr(a
->ref
, b
->ref
);
84 ret
= compare_expr(a
->u
.ext
, b
->u
.ext
);
87 return compare_expr(a
->ext2
, b
->ext2
);
96 ret
= compare_expr(a
->ref
, b
->ref
);
99 return compare_expr(a
->u
.ext
, b
->u
.ext
);
105 return compare_expr(a
->ref
, b
->ref
);
112 #define WRITE_FCTYPE(file, fctype, typestring_offset) \
115 fprintf(file, "/* %2u */\n", typestring_offset); \
116 print_file((file), 2, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
120 static int print_file(FILE *file
, int indent
, const char *format
, ...)
127 va_start(va
, format
);
128 for (i
= 0; i
< indent
; i
++)
130 r
= vfprintf(file
, format
, va
);
135 static void write_formatdesc(FILE *f
, int indent
, const char *str
)
137 print_file(f
, indent
, "typedef struct _MIDL_%s_FORMAT_STRING\n", str
);
138 print_file(f
, indent
, "{\n");
139 print_file(f
, indent
+ 1, "short Pad;\n");
140 print_file(f
, indent
+ 1, "unsigned char Format[%s_FORMAT_STRING_SIZE];\n", str
);
141 print_file(f
, indent
, "} MIDL_%s_FORMAT_STRING;\n", str
);
142 print_file(f
, indent
, "\n");
145 void write_formatstringsdecl(FILE *f
, int indent
, ifref_list_t
*ifaces
, int for_objects
)
147 print_file(f
, indent
, "#define TYPE_FORMAT_STRING_SIZE %d\n",
148 get_size_typeformatstring(ifaces
, for_objects
));
150 print_file(f
, indent
, "#define PROC_FORMAT_STRING_SIZE %d\n",
151 get_size_procformatstring(ifaces
, for_objects
));
154 write_formatdesc(f
, indent
, "TYPE");
155 write_formatdesc(f
, indent
, "PROC");
157 print_file(f
, indent
, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;\n");
158 print_file(f
, indent
, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;\n");
159 print_file(f
, indent
, "\n");
162 static inline int is_base_type(unsigned char type
)
181 case RPC_FC_ERROR_STATUS_T
:
182 case RPC_FC_BIND_PRIMITIVE
:
190 static size_t write_procformatstring_var(FILE *file
, int indent
,
191 const var_t
*var
, int is_return
, unsigned int *type_offset
)
194 int ptr_level
= var
->ptr_level
;
195 const type_t
*type
= var
->type
;
197 int is_in
= is_attr(var
->attrs
, ATTR_IN
);
198 int is_out
= is_attr(var
->attrs
, ATTR_OUT
);
200 if (!is_in
&& !is_out
) is_in
= TRUE
;
202 if (ptr_level
== 0 && !var
->array
&& is_base_type(type
->type
))
205 print_file(file
, indent
, "0x53, /* FC_RETURN_PARAM_BASETYPE */\n");
207 print_file(file
, indent
, "0x4e, /* FC_IN_PARAM_BASETYPE */\n");
211 #define CASE_BASETYPE(fctype) \
213 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
214 size = 2; /* includes param type prefix */ \
217 CASE_BASETYPE(FC_BYTE
);
218 CASE_BASETYPE(FC_CHAR
);
219 CASE_BASETYPE(FC_WCHAR
);
220 CASE_BASETYPE(FC_USHORT
);
221 CASE_BASETYPE(FC_SHORT
);
222 CASE_BASETYPE(FC_ULONG
);
223 CASE_BASETYPE(FC_LONG
);
224 CASE_BASETYPE(FC_HYPER
);
225 CASE_BASETYPE(FC_IGNORE
);
226 CASE_BASETYPE(FC_USMALL
);
227 CASE_BASETYPE(FC_SMALL
);
228 CASE_BASETYPE(FC_FLOAT
);
229 CASE_BASETYPE(FC_DOUBLE
);
230 CASE_BASETYPE(FC_ERROR_STATUS_T
);
233 case RPC_FC_BIND_PRIMITIVE
:
234 print_file(file
, indent
, "0x%02x, /* FC_IGNORE */\n", RPC_FC_IGNORE
);
235 size
= 2; /* includes param type prefix */
239 error("Unknown/unsupported type: %s (0x%02x)\n", var
->name
, type
->type
);
246 print_file(file
, indent
, "0x52, /* FC_RETURN_PARAM */\n");
247 else if (is_in
&& is_out
)
248 print_file(file
, indent
, "0x50, /* FC_IN_OUT_PARAM */\n");
250 print_file(file
, indent
, "0x51, /* FC_OUT_PARAM */\n");
252 print_file(file
, indent
, "0x4d, /* FC_IN_PARAM */\n");
254 print_file(file
, indent
, "0x01,\n");
255 print_file(file
, indent
, "NdrFcShort(0x%x),\n", *type_offset
);
256 size
= 4; /* includes param type prefix */
258 *type_offset
+= get_size_typeformatstring_var(var
);
262 void write_procformatstring(FILE *file
, const ifref_list_t
*ifaces
, int for_objects
)
264 const ifref_t
*iface
;
267 unsigned int type_offset
= 2;
269 print_file(file
, indent
, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
270 print_file(file
, indent
, "{\n");
272 print_file(file
, indent
, "0,\n");
273 print_file(file
, indent
, "{\n");
276 if (ifaces
) LIST_FOR_EACH_ENTRY( iface
, ifaces
, const ifref_t
, entry
)
278 if (for_objects
!= is_object(iface
->iface
->attrs
) || is_local(iface
->iface
->attrs
))
281 if (iface
->iface
->funcs
)
284 LIST_FOR_EACH_ENTRY( func
, iface
->iface
->funcs
, const func_t
, entry
)
286 /* emit argument data */
289 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
290 write_procformatstring_var(file
, indent
, var
, FALSE
, &type_offset
);
293 /* emit return value data */
295 if (is_void(var
->type
, NULL
))
297 print_file(file
, indent
, "0x5b, /* FC_END */\n");
298 print_file(file
, indent
, "0x5c, /* FC_PAD */\n");
301 write_procformatstring_var(file
, indent
, var
, TRUE
,
307 print_file(file
, indent
, "0x0\n");
309 print_file(file
, indent
, "}\n");
311 print_file(file
, indent
, "};\n");
312 print_file(file
, indent
, "\n");
315 /* write conformance / variance descriptor */
316 static size_t write_conf_or_var_desc(FILE *file
, const func_t
*func
, const type_t
*structure
, const expr_t
*expr
)
318 unsigned char operator_type
= 0;
319 const char *operator_string
= "no operators";
320 const expr_t
*subexpr
= expr
;
321 unsigned char correlation_type
;
323 if (!file
) return 4; /* optimisation for sizing pass */
327 if (expr
->cval
> UCHAR_MAX
* (USHRT_MAX
+ 1) + USHRT_MAX
)
328 error("write_conf_or_var_desc: constant value %ld is greater than "
329 "the maximum constant size of %d\n", expr
->cval
,
330 UCHAR_MAX
* (USHRT_MAX
+ 1) + USHRT_MAX
);
332 print_file(file
, 2, "0x%x, /* Corr desc: constant, val = %ld */\n",
333 RPC_FC_CONSTANT_CONFORMANCE
, expr
->cval
);
334 print_file(file
, 2, "0x%x,\n", expr
->cval
& ~USHRT_MAX
);
335 print_file(file
, 2, "NdrFcShort(0x%x),\n", expr
->cval
& USHRT_MAX
);
340 switch (subexpr
->type
)
343 subexpr
= subexpr
->ref
;
344 operator_type
= RPC_FC_DEREFERENCE
;
345 operator_string
= "FC_DEREFERENCE";
348 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 2))
350 subexpr
= subexpr
->ref
;
351 operator_type
= RPC_FC_DIV_2
;
352 operator_string
= "FC_DIV_2";
356 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 2))
358 subexpr
= subexpr
->ref
;
359 operator_type
= RPC_FC_MULT_2
;
360 operator_string
= "FC_MULT_2";
364 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 1))
366 subexpr
= subexpr
->ref
;
367 operator_type
= RPC_FC_SUB_1
;
368 operator_string
= "FC_SUB_1";
372 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 1))
374 subexpr
= subexpr
->ref
;
375 operator_type
= RPC_FC_ADD_1
;
376 operator_string
= "FC_ADD_1";
383 if (subexpr
->type
== EXPR_IDENTIFIER
)
385 const type_t
*correlation_variable
= NULL
;
386 unsigned char correlation_variable_type
;
387 unsigned char param_type
= 0;
388 const char *param_type_string
= NULL
;
396 if (structure
->fields
) LIST_FOR_EACH_ENTRY( var
, structure
->fields
, const var_t
, entry
)
398 offset
-= type_memsize(var
->type
, var
->ptr_level
, var
->array
);
399 if (!strcmp(var
->name
, subexpr
->u
.sval
))
401 correlation_variable
= var
->type
;
405 if (!correlation_variable
)
406 error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
409 correlation_type
= RPC_FC_NORMAL_CONFORMANCE
;
416 if (func
->args
) LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
418 if (!strcmp(var
->name
, subexpr
->u
.sval
))
420 correlation_variable
= var
->type
;
423 /* FIXME: not all stack variables are sizeof(void *) */
424 offset
+= sizeof(void *);
426 if (!correlation_variable
)
427 error("write_conf_or_var_desc: couldn't find variable %s in function\n",
430 correlation_type
= RPC_FC_TOP_LEVEL_CONFORMANCE
;
433 correlation_variable_type
= correlation_variable
->type
;
435 switch (correlation_variable_type
)
439 param_type
= RPC_FC_SMALL
;
440 param_type_string
= "FC_SMALL";
444 param_type
= RPC_FC_USMALL
;
445 param_type_string
= "FC_USMALL";
449 param_type
= RPC_FC_SHORT
;
450 param_type_string
= "FC_SHORT";
453 param_type
= RPC_FC_USHORT
;
454 param_type_string
= "FC_USHORT";
457 param_type
= RPC_FC_LONG
;
458 param_type_string
= "FC_LONG";
461 param_type
= RPC_FC_ULONG
;
462 param_type_string
= "FC_ULONG";
465 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n",
466 correlation_variable_type
);
469 print_file(file
, 2, "0x%x, /* Corr desc: %s%s */\n",
470 correlation_type
| param_type
,
471 correlation_type
== RPC_FC_TOP_LEVEL_CONFORMANCE
? "parameter, " : "",
473 print_file(file
, 2, "0x%x, /* %s */\n", operator_type
, operator_string
);
474 print_file(file
, 2, "NdrFcShort(0x%x), /* %soffset = %d */\n",
476 correlation_type
== RPC_FC_TOP_LEVEL_CONFORMANCE
? "x86 stack size / " : "",
481 unsigned int callback_offset
= 0;
485 struct expr_eval_routine
*eval
;
488 LIST_FOR_EACH_ENTRY(eval
, &expr_eval_routines
, struct expr_eval_routine
, entry
)
490 if (!strcmp(eval
->structure
->name
, structure
->name
) &&
491 !compare_expr(eval
->expr
, expr
))
501 eval
= xmalloc(sizeof(*eval
));
502 eval
->structure
= structure
;
503 eval
->structure_size
= fields_memsize(structure
->fields
);
505 list_add_tail(&expr_eval_routines
, &eval
->entry
);
508 correlation_type
= RPC_FC_NORMAL_CONFORMANCE
;
512 error("write_conf_or_var_desc: top-level callback conformance unimplemented\n");
513 correlation_type
= RPC_FC_TOP_LEVEL_CONFORMANCE
;
516 if (callback_offset
> USHRT_MAX
)
517 error("Maximum number of callback routines reached\n");
519 print_file(file
, 2, "0x%x, /* Corr desc: %s */\n",
521 correlation_type
== RPC_FC_TOP_LEVEL_CONFORMANCE
? "parameter" : "");
522 print_file(file
, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK
, "FC_CALLBACK");
523 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", callback_offset
, callback_offset
);
528 static size_t fields_memsize(const var_list_t
*fields
)
533 if (!fields
) return 0;
534 LIST_FOR_EACH_ENTRY( v
, fields
, const var_t
, entry
)
535 size
+= type_memsize(v
->type
, v
->ptr_level
, v
->array
);
540 static size_t type_memsize(const type_t
*t
, int ptr_level
, const array_dims_t
*array
)
545 return sizeof(void *);
563 case RPC_FC_ERROR_STATUS_T
:
573 case RPC_FC_CVSTRUCT
:
574 case RPC_FC_CPSTRUCT
:
577 case RPC_FC_BOGUS_STRUCT
:
578 case RPC_FC_ENCAPSULATED_UNION
:
579 case RPC_FC_NON_ENCAPSULATED_UNION
:
580 size
= fields_memsize(t
->fields
);
583 error("type_memsize: Unknown type %d\n", t
->type
);
590 LIST_FOR_EACH_ENTRY( dim
, array
, expr_t
, entry
)
600 size_t get_type_memsize(const type_t
*type
)
602 return type_memsize(type
, 0, NULL
);
605 static int write_pointers(FILE *file
, const attr_list_t
*attrs
,
606 const type_t
*type
, int ptr_level
,
607 const array_dims_t
*array
, int level
,
608 unsigned int *typestring_offset
)
610 int pointers_written
= 0;
613 /* don't generate a pointer for first-level arrays since we want to
614 * descend into them to write their pointers, not stop here */
615 if ((level
== 0 || ptr_level
== 0) && is_array_type(attrs
, ptr_level
, array
))
617 return write_pointers(file
, NULL
, type
, 0, NULL
, level
+ 1, typestring_offset
);
622 /* FIXME: only general algorithm implemented, not the actual writing */
623 error("write_pointers: Writing type format string for pointer is unimplemented\n");
629 /* note: don't descend into complex structures or unions since these
630 * will always be generated as a separate type */
632 case RPC_FC_CVSTRUCT
:
633 case RPC_FC_CPSTRUCT
:
636 if (!type
->fields
) break;
637 LIST_FOR_EACH_ENTRY( v
, type
->fields
, const var_t
, entry
)
638 pointers_written
+= write_pointers(file
, v
->attrs
, v
->type
,
639 v
->ptr_level
, v
->array
,
650 return pointers_written
;
653 static size_t write_pointer_description(FILE *file
, const attr_list_t
*attrs
,
654 const type_t
*type
, int ptr_level
,
655 const array_dims_t
*array
, int level
,
656 size_t typestring_offset
)
661 /* don't generate a pointer for first-level arrays since we want to
662 * descend into them to write their pointers, not stop here */
663 if ((level
== 0 || ptr_level
== 0) && is_array_type(attrs
, ptr_level
, array
))
665 return write_pointer_description(file
, NULL
, type
, 0, NULL
,
666 level
+ 1, typestring_offset
);
671 /* FIXME: only general algorithm implemented, not the actual writing */
672 error("write_pointer_description: Writing pointer description is unimplemented\n");
676 /* FIXME: search through all refs for pointers too */
680 /* note: don't descend into complex structures or unions since these
681 * will always be generated as a separate type */
683 case RPC_FC_CVSTRUCT
:
684 case RPC_FC_CPSTRUCT
:
687 if (!type
->fields
) break;
688 LIST_FOR_EACH_ENTRY( v
, type
->fields
, const var_t
, entry
)
689 size
+= write_pointer_description(file
, v
->attrs
, v
->type
,
690 v
->ptr_level
, v
->array
,
704 static size_t write_string_tfs(FILE *file
, const attr_list_t
*attrs
,
705 const type_t
*type
, const array_dims_t
*array
,
706 const char *name
, unsigned int *typestring_offset
)
708 const expr_t
*size_is
= get_attrp(attrs
, ATTR_SIZEIS
);
709 int has_size
= size_is
&& (size_is
->type
!= EXPR_VOID
);
710 size_t start_offset
= *typestring_offset
;
711 unsigned char flags
= 0;
717 pointer_type
= type
->type
;
721 pointer_type
= get_attrv(attrs
, ATTR_POINTERTYPE
);
724 pointer_type
= RPC_FC_RP
;
726 if (!get_attrp(attrs
, ATTR_SIZEIS
))
727 flags
|= RPC_FC_P_SIMPLEPOINTER
;
731 if ((rtype
!= RPC_FC_BYTE
) && (rtype
!= RPC_FC_CHAR
) && (rtype
!= RPC_FC_WCHAR
))
733 error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", rtype
, name
);
737 print_file(file
, 2,"0x%x, 0x%x, /* %s%s */\n",
739 pointer_type
== RPC_FC_FP
? "FC_FP" : (pointer_type
== RPC_FC_UP
? "FC_UP" : "FC_RP"),
740 (flags
& RPC_FC_P_SIMPLEPOINTER
) ? " [simple_pointer]" : "");
741 *typestring_offset
+= 2;
743 if (!(flags
& RPC_FC_P_SIMPLEPOINTER
))
745 print_file(file
, 2, "NdrFcShort(0x2),\n");
746 *typestring_offset
+= 2;
749 if (array
&& !is_conformant_array(array
))
751 /* FIXME: multi-dimensional array */
752 const expr_t
*dim
= LIST_ENTRY( list_head( array
), expr_t
, entry
);
753 if (dim
->cval
> USHRT_MAX
)
754 error("array size for parameter %s exceeds %d bytes by %ld bytes\n",
755 name
, USHRT_MAX
, dim
->cval
- USHRT_MAX
);
757 if (rtype
== RPC_FC_CHAR
)
758 WRITE_FCTYPE(file
, FC_CSTRING
, *typestring_offset
);
760 WRITE_FCTYPE(file
, FC_WSTRING
, *typestring_offset
);
761 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
762 *typestring_offset
+= 2;
764 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", dim
->cval
, dim
->cval
);
765 *typestring_offset
+= 2;
771 if (rtype
== RPC_FC_CHAR
)
772 WRITE_FCTYPE(file
, FC_C_CSTRING
, *typestring_offset
);
774 WRITE_FCTYPE(file
, FC_C_WSTRING
, *typestring_offset
);
775 print_file(file
, 2, "0x%x, /* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED
);
776 *typestring_offset
+= 2;
778 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
, NULL
, size_is
);
784 if (rtype
== RPC_FC_CHAR
)
785 WRITE_FCTYPE(file
, FC_C_CSTRING
, *typestring_offset
);
787 WRITE_FCTYPE(file
, FC_C_WSTRING
, *typestring_offset
);
788 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
789 *typestring_offset
+= 2;
795 static size_t write_array_tfs(FILE *file
, const attr_list_t
*attrs
,
796 const type_t
*type
, const array_dims_t
*array
,
797 const char *name
, unsigned int *typestring_offset
)
799 const expr_t
*length_is
= get_attrp(attrs
, ATTR_LENGTHIS
);
800 const expr_t
*size_is
= get_attrp(attrs
, ATTR_SIZEIS
);
801 int has_length
= length_is
&& (length_is
->type
!= EXPR_VOID
);
802 int has_size
= (size_is
&& (size_is
->type
!= EXPR_VOID
)) || is_conformant_array(array
);
804 int pointer_type
= get_attrv(attrs
, ATTR_POINTERTYPE
);
806 pointer_type
= RPC_FC_RP
;
808 print_file(file
, 2, "0x%x, 0x00, /* %s */\n",
810 pointer_type
== RPC_FC_FP
? "FC_FP" : (pointer_type
== RPC_FC_UP
? "FC_UP" : "FC_RP"));
811 print_file(file
, 2, "NdrFcShort(0x2),\n");
812 *typestring_offset
+= 4;
814 if (array
&& list_count(array
) > 1) /* multi-dimensional array */
816 error("write_array_tfs: Multi-dimensional arrays not implemented yet (param %s)\n", name
);
821 const expr_t
*dim
= LIST_ENTRY( list_head( array
), expr_t
, entry
);
822 size_t pointer_start_offset
= *typestring_offset
;
825 if (write_pointers(file
, attrs
, type
, 0, array
, 0, typestring_offset
) > 0)
828 start_offset
= *typestring_offset
;
830 if (!has_length
&& !has_size
)
833 size_t size
= type_memsize(type
, 0, array
);
834 if (size
< USHRT_MAX
)
836 WRITE_FCTYPE(file
, FC_SMFARRAY
, *typestring_offset
);
838 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
840 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", size
, size
);
841 *typestring_offset
+= 4;
845 WRITE_FCTYPE(file
, FC_LGFARRAY
, *typestring_offset
);
847 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
849 print_file(file
, 2, "NdrFcLong(0x%x), /* %d */\n", size
, size
);
850 *typestring_offset
+= 6;
855 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
856 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
857 *typestring_offset
+= 2;
858 *typestring_offset
= write_pointer_description(file
, attrs
,
859 type
, 0, array
, 0, pointer_start_offset
);
860 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
861 *typestring_offset
+= 1;
864 print_file(file
, 2, "0x0, /* FIXME: write out conversion data */\n");
865 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
866 *typestring_offset
+= 2;
870 else if (has_length
&& !has_size
)
873 size_t element_size
= type_memsize(type
, 0, NULL
);
874 size_t elements
= dim
->cval
;
875 size_t total_size
= element_size
* elements
;
877 if (total_size
< USHRT_MAX
)
879 WRITE_FCTYPE(file
, FC_SMVARRAY
, *typestring_offset
);
881 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
883 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", total_size
, total_size
);
884 /* number of elements */
885 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", elements
, elements
);
886 *typestring_offset
+= 6;
890 WRITE_FCTYPE(file
, FC_LGVARRAY
, *typestring_offset
);
892 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
894 print_file(file
, 2, "NdrFcLong(0x%x), /* %d */\n", total_size
, total_size
);
895 /* number of elements */
896 print_file(file
, 2, "NdrFcLong(0x%x), /* %d */\n", elements
, elements
);
897 *typestring_offset
+= 10;
900 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", element_size
, element_size
);
901 *typestring_offset
+= 2;
903 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
909 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
910 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
911 *typestring_offset
+= 2;
912 *typestring_offset
+= write_pointer_description(file
, attrs
,
913 type
, 0, array
, 0, pointer_start_offset
);
914 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
915 *typestring_offset
+= 1;
918 print_file(file
, 2, "0x0, /* FIXME: write out conversion data */\n");
919 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
920 *typestring_offset
+= 2;
924 else if (!has_length
&& has_size
)
926 /* conformant array */
927 size_t element_size
= type_memsize(type
, 0, NULL
);
929 WRITE_FCTYPE(file
, FC_CARRAY
, *typestring_offset
);
931 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
933 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", element_size
, element_size
);
934 *typestring_offset
+= 4;
936 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
938 size_is
? size_is
: dim
);
942 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
943 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
944 *typestring_offset
+= 2;
945 *typestring_offset
+= write_pointer_description(file
, attrs
,
946 type
, 0, array
, 0, pointer_start_offset
);
947 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
948 *typestring_offset
+= 1;
951 print_file(file
, 2, "0x%x, /* FIXME: write out conversion data */\n", type
->type
);
952 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
953 *typestring_offset
+= 2;
959 /* conformant varying array */
960 size_t element_size
= type_memsize(type
, 0, NULL
);
962 WRITE_FCTYPE(file
, FC_CVARRAY
, *typestring_offset
);
964 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
966 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", element_size
, element_size
);
967 *typestring_offset
+= 4;
969 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
971 size_is
? size_is
: dim
);
972 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
978 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
979 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
980 *typestring_offset
+= 2;
981 *typestring_offset
+= write_pointer_description(file
, attrs
,
982 type
, 0, array
, 0, pointer_start_offset
);
983 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
984 *typestring_offset
+= 1;
987 print_file(file
, 2, "0x0, /* FIXME: write out conversion data */\n");
988 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
989 *typestring_offset
+= 2;
996 static const var_t
*find_array_or_string_in_struct(const type_t
*type
)
998 const var_t
*last_field
= LIST_ENTRY( list_tail(type
->fields
), const var_t
, entry
);
1000 if (is_array_type(last_field
->attrs
, last_field
->ptr_level
, last_field
->array
))
1003 assert((last_field
->type
->type
== RPC_FC_CSTRUCT
) ||
1004 (last_field
->type
->type
== RPC_FC_CPSTRUCT
) ||
1005 (last_field
->type
->type
== RPC_FC_CVSTRUCT
));
1007 return find_array_or_string_in_struct(last_field
->type
);
1010 static size_t write_struct_members(FILE *file
, const type_t
*type
)
1012 size_t typestring_size
= 0;
1015 if (type
->fields
) LIST_FOR_EACH_ENTRY( field
, type
->fields
, const var_t
, entry
)
1017 unsigned char rtype
= field
->type
->type
;
1019 if (is_base_type(rtype
))
1023 #define CASE_BASETYPE(fctype) \
1024 case RPC_##fctype: \
1025 print_file(file, 2, "0x%02x,\t\t/* " #fctype " */\n", RPC_##fctype); \
1026 typestring_size++; \
1028 CASE_BASETYPE(FC_BYTE
);
1029 CASE_BASETYPE(FC_CHAR
);
1030 CASE_BASETYPE(FC_SMALL
);
1031 CASE_BASETYPE(FC_USMALL
);
1032 CASE_BASETYPE(FC_WCHAR
);
1033 CASE_BASETYPE(FC_SHORT
);
1034 CASE_BASETYPE(FC_USHORT
);
1035 CASE_BASETYPE(FC_LONG
);
1036 CASE_BASETYPE(FC_ULONG
);
1037 CASE_BASETYPE(FC_FLOAT
);
1038 CASE_BASETYPE(FC_HYPER
);
1039 CASE_BASETYPE(FC_DOUBLE
);
1040 CASE_BASETYPE(FC_ENUM16
);
1041 CASE_BASETYPE(FC_ENUM32
);
1042 CASE_BASETYPE(FC_IGNORE
);
1043 CASE_BASETYPE(FC_ERROR_STATUS_T
);
1046 #undef CASE_BASETYPE
1050 error("Unsupported member type 0x%x\n", rtype
);
1053 if (typestring_size
% 1)
1055 print_file(file
, 2, "0x%x,\t\t/* FC_PAD */\n", RPC_FC_PAD
);
1059 print_file(file
, 2, "0x%x,\t\t/* FC_END */\n", RPC_FC_END
);
1062 return typestring_size
;
1065 static size_t write_struct_tfs(FILE *file
, const type_t
*type
,
1066 const char *name
, unsigned int *typestring_offset
)
1068 unsigned int total_size
;
1070 size_t start_offset
;
1071 size_t array_offset
;
1072 size_t pointer_offset
;
1077 case RPC_FC_PSTRUCT
:
1078 total_size
= type_memsize(type
, 0, NULL
);
1080 if (total_size
> USHRT_MAX
)
1081 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1082 name
, USHRT_MAX
, total_size
- USHRT_MAX
);
1084 if (type
->type
== RPC_FC_PSTRUCT
)
1086 pointer_offset
= *typestring_offset
;
1087 write_pointers(file
, NULL
, type
, 0, NULL
, 0, typestring_offset
);
1089 else pointer_offset
= 0; /* silence warning */
1091 start_offset
= *typestring_offset
;
1092 if (type
->type
== RPC_FC_STRUCT
)
1093 WRITE_FCTYPE(file
, FC_STRUCT
, *typestring_offset
);
1095 WRITE_FCTYPE(file
, FC_PSTRUCT
, *typestring_offset
);
1097 print_file(file
, 2, "0x3,\n"); /* FIXME */
1099 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", total_size
, total_size
);
1100 *typestring_offset
+= 4;
1102 if (type
->type
== RPC_FC_PSTRUCT
)
1104 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
1105 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
1106 *typestring_offset
+= 2;
1107 *typestring_offset
+= write_pointer_description(file
, NULL
,
1108 type
, 0, NULL
, 0, pointer_offset
);
1109 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1110 *typestring_offset
+= 1;
1114 *typestring_offset
+= write_struct_members(file
, type
);
1115 return start_offset
;
1116 case RPC_FC_CSTRUCT
:
1117 case RPC_FC_CPSTRUCT
:
1118 total_size
= type_memsize(type
, 0, NULL
);
1120 if (total_size
> USHRT_MAX
)
1121 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1122 name
, USHRT_MAX
, total_size
- USHRT_MAX
);
1124 array
= find_array_or_string_in_struct(type
);
1125 current_structure
= type
;
1126 array_offset
= write_array_tfs(file
, array
->attrs
, array
->type
,
1127 array
->array
, array
->name
,
1129 current_structure
= NULL
;
1131 if (type
->type
== RPC_FC_CPSTRUCT
)
1133 pointer_offset
= *typestring_offset
;
1134 write_pointers(file
, NULL
, type
, 0, NULL
, 0, typestring_offset
);
1136 else pointer_offset
= 0; /* silence warning */
1138 start_offset
= *typestring_offset
;
1139 if (type
->type
== RPC_FC_CSTRUCT
)
1140 WRITE_FCTYPE(file
, FC_CSTRUCT
, *typestring_offset
);
1142 WRITE_FCTYPE(file
, FC_CPSTRUCT
, *typestring_offset
);
1144 print_file(file
, 2, "0x0,\n");
1146 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", total_size
, total_size
);
1147 *typestring_offset
+= 4;
1148 print_file(file
, 2, "NdrFcShort(0x%x), /* offset = %d (%u) */\n",
1149 array_offset
- *typestring_offset
,
1150 array_offset
- *typestring_offset
,
1152 *typestring_offset
+= 2;
1154 if (type
->type
== RPC_FC_CPSTRUCT
)
1156 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
1157 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
1158 *typestring_offset
+= 2;
1159 *typestring_offset
+= write_pointer_description(file
, NULL
,
1160 type
, 0, NULL
, 0, pointer_offset
);
1161 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1162 *typestring_offset
+= 1;
1165 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1166 *typestring_offset
+= 1;
1168 return start_offset
;
1169 case RPC_FC_CVSTRUCT
:
1170 total_size
= type_memsize(type
, 0, NULL
);
1172 if (total_size
> USHRT_MAX
)
1173 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1174 name
, USHRT_MAX
, total_size
- USHRT_MAX
);
1176 array
= find_array_or_string_in_struct(type
);
1177 current_structure
= type
;
1178 if (is_attr(array
->attrs
, ATTR_STRING
))
1179 array_offset
= write_string_tfs(file
, array
->attrs
, array
->type
,
1180 array
->array
, array
->name
,
1183 array_offset
= write_array_tfs(file
, array
->attrs
, array
->type
,
1184 array
->array
, array
->name
,
1186 current_structure
= NULL
;
1188 pointer_offset
= *typestring_offset
;
1189 if (!write_pointers(file
, NULL
, type
, 0, NULL
, 0, typestring_offset
))
1192 start_offset
= *typestring_offset
;
1193 WRITE_FCTYPE(file
, FC_CVSTRUCT
, *typestring_offset
);
1195 print_file(file
, 2, "0x0,\n");
1197 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", total_size
, total_size
);
1198 *typestring_offset
+= 4;
1199 print_file(file
, 2, "NdrFcShort(0x%x), /* offset = %d (%u) */\n",
1200 array_offset
- *typestring_offset
,
1201 array_offset
- *typestring_offset
,
1203 *typestring_offset
+= 2;
1205 if (pointer_offset
!= 0)
1207 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
1208 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
1209 *typestring_offset
+= 2;
1210 *typestring_offset
+= write_pointer_description(file
, NULL
,
1211 type
, 0, NULL
, 0, pointer_offset
);
1212 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1213 *typestring_offset
+= 1;
1216 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1217 *typestring_offset
+= 1;
1219 return start_offset
;
1221 error("write_struct_tfs: Unimplemented for type 0x%x\n", type
->type
);
1222 return *typestring_offset
;
1226 static void write_pointer_only_tfs(FILE *file
, const attr_list_t
*attrs
, int pointer_type
,
1227 unsigned char flags
, size_t offset
,
1228 unsigned int *typeformat_offset
)
1230 int in_attr
, out_attr
;
1231 in_attr
= is_attr(attrs
, ATTR_IN
);
1232 out_attr
= is_attr(attrs
, ATTR_OUT
);
1233 if (!in_attr
&& !out_attr
) in_attr
= 1;
1235 if (out_attr
&& !in_attr
&& pointer_type
== RPC_FC_RP
)
1238 print_file(file
, 2, "0x%x, 0x%x,\t\t/* %s",
1241 pointer_type
== RPC_FC_FP
? "FC_FP" : (pointer_type
== RPC_FC_UP
? "FC_UP" : "FC_RP"));
1245 fprintf(file
, " [allocated_on_stack]");
1247 fprintf(file
, " [pointer_deref]");
1248 fprintf(file
, " */\n");
1251 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", offset
, offset
);
1252 *typeformat_offset
+= 4;
1255 static size_t write_union_tfs(FILE *file
, const attr_list_t
*attrs
,
1256 const type_t
*type
, const char *name
,
1257 unsigned int *typeformat_offset
)
1259 error("write_union_tfs: Unimplemented\n");
1260 return *typeformat_offset
;
1263 static size_t write_ip_tfs(FILE *file
, const attr_list_t
*attrs
,
1264 const char *name
, unsigned int *typeformat_offset
)
1267 size_t start_offset
= *typeformat_offset
;
1268 const UUID
*uuid
= get_attrp(attrs
, ATTR_UUID
);
1271 error("%s: interface %s missing UUID\n", __FUNCTION__
, name
);
1273 print_file(file
, 2, "0x2f,\t/* FC_IP */\n");
1274 print_file(file
, 2, "0x5a,\t/* FC_CONSTANT_IID */\n");
1275 print_file(file
, 2, "NdrFcLong(0x%08lx),\n", uuid
->Data1
);
1276 print_file(file
, 2, "NdrFcShort(0x%04x),\n", uuid
->Data2
);
1277 print_file(file
, 2, "NdrFcShort(0x%04x),\n", uuid
->Data3
);
1278 for (i
= 0; i
< 8; ++i
)
1279 print_file(file
, 2, "0x%02x,\n", uuid
->Data4
[i
]);
1282 fprintf(file
, "\n");
1284 *typeformat_offset
+= 18;
1285 return start_offset
;
1288 static int get_ptr_attr(const type_t
*t
, int def_type
)
1292 int ptr_attr
= get_attrv(t
->attrs
, ATTR_POINTERTYPE
);
1295 if (t
->kind
!= TKIND_ALIAS
)
1301 static size_t write_typeformatstring_var(FILE *file
, int indent
,
1302 const var_t
*var
, unsigned int *typeformat_offset
)
1304 const type_t
*type
= var
->type
;
1305 int var_ptrs
= var
->ptr_level
, type_ptrs
= 0;
1306 int is_str
= is_attr(var
->attrs
, ATTR_STRING
);
1308 chat("write_typeformatstring_var: %s\n", var
->name
);
1312 is_str
= is_str
|| is_attr(type
->attrs
, ATTR_STRING
);
1313 if (type
->kind
== TKIND_ALIAS
)
1315 else if (is_ptr(type
))
1329 int ptr_level
= var_ptrs
+ type_ptrs
;
1330 int pointer_type
= 0;
1332 chat("write_typeformatstring: type->type = 0x%x, type->name = %s, ptr_level = %d\n", type
->type
, type
->name
, ptr_level
);
1334 /* var attrs only effect the rightmost pointer */
1335 if ((0 < var
->ptr_level
&& var_ptrs
== var
->ptr_level
)
1336 || (var
->ptr_level
== 0 && type
== var
->type
))
1338 int pointer_attr
= get_attrv(var
->attrs
, ATTR_POINTERTYPE
);
1342 error("'%s': pointer attribute applied to non-pointer type",
1344 pointer_type
= pointer_attr
;
1347 pointer_type
= RPC_FC_RP
;
1349 else /* pointers below other pointers default to unique */
1350 pointer_type
= var_ptrs
? RPC_FC_UP
: get_ptr_attr(type
, RPC_FC_UP
);
1352 if (is_str
&& ptr_level
+ (var
->array
!= NULL
) == 1)
1353 return write_string_tfs(file
, var
->attrs
, type
, var
->array
, var
->name
, typeformat_offset
);
1355 if (is_array_type(var
->attrs
, ptr_level
, var
->array
))
1356 return write_array_tfs(file
, var
->attrs
, type
, var
->array
, var
->name
, typeformat_offset
);
1360 /* basic types don't need a type format string */
1361 if (is_base_type(type
->type
))
1367 case RPC_FC_PSTRUCT
:
1368 case RPC_FC_CSTRUCT
:
1369 case RPC_FC_CPSTRUCT
:
1370 case RPC_FC_CVSTRUCT
:
1371 case RPC_FC_BOGUS_STRUCT
:
1372 return write_struct_tfs(file
, type
, var
->name
, typeformat_offset
);
1373 case RPC_FC_ENCAPSULATED_UNION
:
1374 case RPC_FC_NON_ENCAPSULATED_UNION
:
1375 return write_union_tfs(file
, var
->attrs
, type
, var
->name
, typeformat_offset
);
1377 case RPC_FC_BIND_PRIMITIVE
:
1381 error("write_typeformatstring_var: Unsupported type 0x%x for variable %s\n", type
->type
, var
->name
);
1384 else if (ptr_level
== 1)
1386 size_t start_offset
= *typeformat_offset
;
1387 int in_attr
= is_attr(var
->attrs
, ATTR_IN
);
1388 int out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
1389 const type_t
*base
= is_ptr(type
) ? type
->ref
: type
;
1391 if (base
->type
== RPC_FC_IP
)
1393 return write_ip_tfs(file
, base
->attrs
, base
->name
, typeformat_offset
);
1396 /* special case for pointers to base types */
1399 #define CASE_BASETYPE(fctype) \
1400 case RPC_##fctype: \
1401 print_file(file, indent, "0x%x, 0x%x, /* %s %s[simple_pointer] */\n", \
1403 (!in_attr && out_attr) ? 0x0C : 0x08, \
1404 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"), \
1405 (!in_attr && out_attr) ? "[allocated_on_stack] " : ""); \
1406 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
1407 print_file(file, indent, "0x5c, /* FC_PAD */\n"); \
1408 *typeformat_offset += 4; \
1410 CASE_BASETYPE(FC_BYTE
);
1411 CASE_BASETYPE(FC_CHAR
);
1412 CASE_BASETYPE(FC_SMALL
);
1413 CASE_BASETYPE(FC_USMALL
);
1414 CASE_BASETYPE(FC_WCHAR
);
1415 CASE_BASETYPE(FC_SHORT
);
1416 CASE_BASETYPE(FC_USHORT
);
1417 CASE_BASETYPE(FC_LONG
);
1418 CASE_BASETYPE(FC_ULONG
);
1419 CASE_BASETYPE(FC_FLOAT
);
1420 CASE_BASETYPE(FC_HYPER
);
1421 CASE_BASETYPE(FC_DOUBLE
);
1422 CASE_BASETYPE(FC_ENUM16
);
1423 CASE_BASETYPE(FC_ENUM32
);
1424 CASE_BASETYPE(FC_IGNORE
);
1425 CASE_BASETYPE(FC_ERROR_STATUS_T
);
1431 assert(ptr_level
> 0);
1434 fprintf(file
, "/* %2u */\n", *typeformat_offset
);
1435 write_pointer_only_tfs(file
, var
->attrs
, pointer_type
,
1436 1 < ptr_level
? 0x10 : 0,
1437 2, typeformat_offset
);
1450 void write_typeformatstring(FILE *file
, const ifref_list_t
*ifaces
, int for_objects
)
1454 unsigned int typeformat_offset
;
1455 const ifref_t
*iface
;
1457 print_file(file
, indent
, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
1458 print_file(file
, indent
, "{\n");
1460 print_file(file
, indent
, "0,\n");
1461 print_file(file
, indent
, "{\n");
1463 print_file(file
, indent
, "NdrFcShort(0x0),\n");
1464 typeformat_offset
= 2;
1466 if (ifaces
) LIST_FOR_EACH_ENTRY( iface
, ifaces
, const ifref_t
, entry
)
1468 if (for_objects
!= is_object(iface
->iface
->attrs
) || is_local(iface
->iface
->attrs
))
1471 if (iface
->iface
->funcs
)
1474 LIST_FOR_EACH_ENTRY( func
, iface
->iface
->funcs
, const func_t
, entry
)
1476 current_func
= func
;
1478 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
1479 write_typeformatstring_var(file
, indent
, var
,
1480 &typeformat_offset
);
1485 print_file(file
, indent
, "0x0\n");
1487 print_file(file
, indent
, "}\n");
1489 print_file(file
, indent
, "};\n");
1490 print_file(file
, indent
, "\n");
1493 static unsigned int get_required_buffer_size_type(
1494 const type_t
*type
, int ptr_level
, const array_dims_t
*array
,
1495 const char *name
, unsigned int *alignment
)
1498 if (ptr_level
== 0 && !array
)
1518 case RPC_FC_ERROR_STATUS_T
:
1528 case RPC_FC_BIND_PRIMITIVE
:
1535 if (!type
->fields
) return 0;
1536 LIST_FOR_EACH_ENTRY( field
, type
->fields
, const var_t
, entry
)
1538 unsigned int alignment
;
1539 size
+= get_required_buffer_size_type(
1540 field
->type
, field
->ptr_level
, field
->array
, field
->name
,
1547 error("get_required_buffer_size: Unknown/unsupported type: %s (0x%02x)\n", name
, type
->type
);
1554 unsigned int get_required_buffer_size(const var_t
*var
, unsigned int *alignment
, enum pass pass
)
1556 expr_t
*size_is
= get_attrp(var
->attrs
, ATTR_SIZEIS
);
1557 int has_size
= (size_is
&& (size_is
->type
!= EXPR_VOID
));
1558 int in_attr
= is_attr(var
->attrs
, ATTR_IN
);
1559 int out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
1561 if (!in_attr
&& !out_attr
)
1566 if (pass
== PASS_OUT
)
1568 if (out_attr
&& var
->ptr_level
> 0)
1570 type_t
*type
= var
->type
;
1572 if (type
->type
== RPC_FC_STRUCT
)
1575 unsigned int size
= 36;
1577 if (!type
->fields
) return size
;
1578 LIST_FOR_EACH_ENTRY( field
, type
->fields
, const var_t
, entry
)
1581 size
+= get_required_buffer_size_type(
1582 field
->type
, field
->ptr_level
, field
->array
, field
->name
,
1592 if ((!out_attr
|| in_attr
) && !has_size
&& !is_attr(var
->attrs
, ATTR_STRING
) && !var
->array
)
1594 if (var
->ptr_level
> 0)
1596 type_t
*type
= var
->type
;
1598 if (is_base_type(type
->type
))
1602 else if (type
->type
== RPC_FC_STRUCT
)
1604 unsigned int size
= 36;
1607 if (!type
->fields
) return size
;
1608 LIST_FOR_EACH_ENTRY( field
, type
->fields
, const var_t
, entry
)
1611 size
+= get_required_buffer_size_type(
1612 field
->type
, field
->ptr_level
, field
->array
, field
->name
,
1620 return get_required_buffer_size_type(var
->type
, var
->ptr_level
, var
->array
, var
->name
, alignment
);
1624 static void print_phase_function(FILE *file
, int indent
, const char *type
,
1625 enum remoting_phase phase
,
1626 const char *varname
, unsigned int type_offset
)
1628 const char *function
;
1631 case PHASE_BUFFERSIZE
:
1632 function
= "BufferSize";
1635 function
= "Marshall";
1637 case PHASE_UNMARSHAL
:
1638 function
= "Unmarshall";
1648 print_file(file
, indent
, "Ndr%s%s(\n", type
, function
);
1650 print_file(file
, indent
, "&_StubMsg,\n");
1651 print_file(file
, indent
, "%s%s,\n",
1652 (phase
== PHASE_UNMARSHAL
) ? "(unsigned char **)&" : "(unsigned char *)",
1654 print_file(file
, indent
, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n",
1655 type_offset
, (phase
== PHASE_UNMARSHAL
) ? "," : ");");
1656 if (phase
== PHASE_UNMARSHAL
)
1657 print_file(file
, indent
, "0);\n");
1661 void print_phase_basetype(FILE *file
, int indent
, enum remoting_phase phase
,
1662 enum pass pass
, const var_t
*var
,
1663 const char *varname
)
1665 const type_t
*type
= var
->type
;
1667 unsigned int alignment
= 0;
1668 unsigned char rtype
;
1670 /* no work to do for other phases, buffer sizing is done elsewhere */
1671 if (phase
!= PHASE_MARSHAL
&& phase
!= PHASE_UNMARSHAL
)
1696 case RPC_FC_ERROR_STATUS_T
:
1708 case RPC_FC_BIND_PRIMITIVE
:
1709 /* no marshalling needed */
1713 error("print_phase_basetype: Unsupported type: %s (0x%02x, ptr_level: 0)\n", var
->name
, rtype
);
1717 print_file(file
, indent
, "_StubMsg.Buffer = (unsigned char *)(((long)_StubMsg.Buffer + %u) & ~0x%x);\n",
1718 alignment
- 1, alignment
- 1);
1720 if (phase
== PHASE_MARSHAL
)
1722 print_file(file
, indent
, "*(");
1723 write_type(file
, var
->type
, NULL
, var
->tname
);
1725 fprintf(file
, " *)_StubMsg.Buffer = *");
1727 fprintf(file
, " *)_StubMsg.Buffer = ");
1728 fprintf(file
, varname
);
1729 fprintf(file
, ";\n");
1731 else if (phase
== PHASE_UNMARSHAL
)
1733 if (pass
== PASS_IN
|| pass
== PASS_RETURN
)
1734 print_file(file
, indent
, "");
1736 print_file(file
, indent
, "*");
1737 fprintf(file
, varname
);
1738 if (pass
== PASS_IN
&& var
->ptr_level
)
1739 fprintf(file
, " = (");
1741 fprintf(file
, " = *(");
1742 write_type(file
, var
->type
, NULL
, var
->tname
);
1743 fprintf(file
, " *)_StubMsg.Buffer;\n");
1746 print_file(file
, indent
, "_StubMsg.Buffer += sizeof(");
1747 write_type(file
, var
->type
, NULL
, var
->tname
);
1748 fprintf(file
, ");\n");
1751 /* returns whether the MaxCount, Offset or ActualCount members need to be
1752 * filled in for the specified phase */
1753 static inline int is_size_needed_for_phase(enum remoting_phase phase
)
1755 return (phase
!= PHASE_UNMARSHAL
);
1758 void write_remoting_arguments(FILE *file
, int indent
, const func_t
*func
,
1759 unsigned int *type_offset
, enum pass pass
,
1760 enum remoting_phase phase
)
1762 const expr_t
*length_is
;
1763 const expr_t
*size_is
;
1764 int in_attr
, out_attr
, has_length
, has_size
, pointer_type
;
1770 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
1772 const type_t
*type
= var
->type
;
1773 unsigned char rtype
;
1775 length_is
= get_attrp(var
->attrs
, ATTR_LENGTHIS
);
1776 size_is
= get_attrp(var
->attrs
, ATTR_SIZEIS
);
1777 has_length
= length_is
&& (length_is
->type
!= EXPR_VOID
);
1778 has_size
= (size_is
&& (size_is
->type
!= EXPR_VOID
)) || (var
->array
&& is_conformant_array(var
->array
));
1780 pointer_type
= get_attrv(var
->attrs
, ATTR_POINTERTYPE
);
1782 pointer_type
= RPC_FC_RP
;
1784 in_attr
= is_attr(var
->attrs
, ATTR_IN
);
1785 out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
1786 if (!in_attr
&& !out_attr
)
1792 if (!in_attr
) goto next
;
1795 if (!out_attr
) goto next
;
1803 if (is_string_type(var
->attrs
, var
->ptr_level
, var
->array
))
1805 if (var
->array
&& !is_conformant_array(var
->array
))
1806 print_phase_function(file
, indent
, "NonConformantString", phase
, var
->name
, *type_offset
);
1809 if (size_is
&& is_size_needed_for_phase(phase
))
1811 print_file(file
, indent
, "_StubMsg.MaxCount = (unsigned long)");
1812 write_expr(file
, size_is
, 1);
1813 fprintf(file
, ";\n");
1816 if ((phase
== PHASE_FREE
) || (pointer_type
== RPC_FC_UP
))
1817 print_phase_function(file
, indent
, "Pointer", phase
, var
->name
, *type_offset
);
1819 print_phase_function(file
, indent
, "ConformantString", phase
, var
->name
,
1820 *type_offset
+ (has_size
? 4 : 2));
1823 else if (is_array_type(var
->attrs
, var
->ptr_level
, var
->array
))
1825 const char *array_type
;
1827 if (var
->array
&& list_count(var
->array
) > 1) /* multi-dimensional array */
1828 array_type
= "ComplexArray";
1831 const expr_t
*dim
= LIST_ENTRY( list_head( var
->array
), expr_t
, entry
);
1832 if (!has_length
&& !has_size
)
1833 array_type
= "FixedArray";
1834 else if (has_length
&& !has_size
)
1836 if (is_size_needed_for_phase(phase
))
1838 print_file(file
, indent
, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1839 print_file(file
, indent
, "_StubMsg.ActualCount = (unsigned long)");
1840 write_expr(file
, length_is
, 1);
1841 fprintf(file
, ";\n\n");
1843 array_type
= "VaryingArray";
1845 else if (!has_length
&& has_size
)
1847 if (is_size_needed_for_phase(phase
) && phase
!= PHASE_FREE
)
1849 print_file(file
, indent
, "_StubMsg.MaxCount = (unsigned long)");
1850 write_expr(file
, size_is
? size_is
: dim
, 1);
1851 fprintf(file
, ";\n\n");
1853 array_type
= "ConformantArray";
1857 if (is_size_needed_for_phase(phase
))
1859 print_file(file
, indent
, "_StubMsg.MaxCount = (unsigned long)");
1860 write_expr(file
, size_is
? size_is
: dim
, 1);
1861 fprintf(file
, ";\n");
1862 print_file(file
, indent
, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1863 print_file(file
, indent
, "_StubMsg.ActualCount = (unsigned long)");
1864 write_expr(file
, length_is
, 1);
1865 fprintf(file
, ";\n\n");
1867 array_type
= "ConformantVaryingArray";
1871 if (!in_attr
&& phase
== PHASE_FREE
)
1873 print_file(file
, indent
, "if (%s)\n", var
->name
);
1875 print_file(file
, indent
, "_StubMsg.pfnFree(%s);\n", var
->name
);
1877 else if (phase
!= PHASE_FREE
)
1879 if (pointer_type
== RPC_FC_UP
)
1880 print_phase_function(file
, indent
, "Pointer", phase
, var
->name
, *type_offset
);
1882 print_phase_function(file
, indent
, array_type
, phase
, var
->name
, *type_offset
+ 4);
1885 else if (var
->ptr_level
== 0 && is_base_type(rtype
))
1887 print_phase_basetype(file
, indent
, phase
, pass
, var
, var
->name
);
1889 else if (var
->ptr_level
== 0)
1891 const char *ndrtype
;
1896 ndrtype
= "SimpleStruct";
1898 case RPC_FC_CSTRUCT
:
1899 case RPC_FC_CPSTRUCT
:
1900 ndrtype
= "ConformantStruct";
1902 case RPC_FC_CVSTRUCT
:
1903 ndrtype
= "ConformantVaryingStruct";
1905 case RPC_FC_BOGUS_STRUCT
:
1906 ndrtype
= "ComplexStruct";
1909 error("write_remoting_arguments: Unsupported type: %s (0x%02x, ptr_level: %d)\n",
1910 var
->name
, rtype
, var
->ptr_level
);
1914 print_phase_function(file
, indent
, ndrtype
, phase
, var
->name
, *type_offset
);
1918 if ((var
->ptr_level
== 1) && (pointer_type
== RPC_FC_RP
) && is_base_type(rtype
))
1920 print_phase_basetype(file
, indent
, phase
, pass
, var
, var
->name
);
1922 else if ((var
->ptr_level
== 1) && (pointer_type
== RPC_FC_RP
) && (rtype
== RPC_FC_STRUCT
))
1924 if (phase
!= PHASE_BUFFERSIZE
&& phase
!= PHASE_FREE
)
1925 print_phase_function(file
, indent
, "SimpleStruct", phase
, var
->name
, *type_offset
+ 4);
1929 print_phase_function(file
, indent
, "Pointer", phase
, var
->name
, *type_offset
);
1932 fprintf(file
, "\n");
1934 *type_offset
+= get_size_typeformatstring_var(var
);
1939 size_t get_size_procformatstring_var(const var_t
*var
)
1941 unsigned int type_offset
= 2;
1942 return write_procformatstring_var(NULL
, 0, var
, FALSE
, &type_offset
);
1946 size_t get_size_typeformatstring_var(const var_t
*var
)
1948 unsigned int type_offset
= 0;
1949 write_typeformatstring_var(NULL
, 0, var
, &type_offset
);
1953 size_t get_size_procformatstring(const ifref_list_t
*ifaces
, int for_objects
)
1955 const ifref_t
*iface
;
1960 if (ifaces
) LIST_FOR_EACH_ENTRY( iface
, ifaces
, const ifref_t
, entry
)
1962 if (for_objects
!= is_object(iface
->iface
->attrs
) || is_local(iface
->iface
->attrs
))
1965 if (iface
->iface
->funcs
)
1967 LIST_FOR_EACH_ENTRY( func
, iface
->iface
->funcs
, const func_t
, entry
)
1969 /* argument list size */
1971 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
1972 size
+= get_size_procformatstring_var(var
);
1975 /* return value size */
1976 if (is_void(var
->type
, NULL
))
1979 size
+= get_size_procformatstring_var(var
);
1986 size_t get_size_typeformatstring(const ifref_list_t
*ifaces
, int for_objects
)
1988 const ifref_t
*iface
;
1993 if (ifaces
) LIST_FOR_EACH_ENTRY( iface
, ifaces
, const ifref_t
, entry
)
1995 if (for_objects
!= is_object(iface
->iface
->attrs
) || is_local(iface
->iface
->attrs
))
1998 if (iface
->iface
->funcs
)
2000 LIST_FOR_EACH_ENTRY( func
, iface
->iface
->funcs
, const func_t
, entry
)
2002 /* argument list size */
2004 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
2005 size
+= get_size_typeformatstring_var(var
);
2012 static void write_struct_expr(FILE *h
, const expr_t
*e
, int brackets
,
2013 const var_list_t
*fields
, const char *structvar
)
2019 fprintf(h
, "%ld", e
->u
.lval
);
2022 fprintf(h
, "0x%lx", e
->u
.lval
);
2024 case EXPR_TRUEFALSE
:
2026 fprintf(h
, "FALSE");
2030 case EXPR_IDENTIFIER
:
2033 LIST_FOR_EACH_ENTRY( field
, fields
, const var_t
, entry
)
2034 if (!strcmp(e
->u
.sval
, field
->name
))
2036 fprintf(h
, "%s->%s", structvar
, e
->u
.sval
);
2040 if (&field
->entry
== fields
) error("no field found for identifier %s\n", e
->u
.sval
);
2045 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
2049 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
2053 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
2057 write_type(h
, e
->u
.tref
->ref
, NULL
, e
->u
.tref
->name
);
2059 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
2062 fprintf(h
, "sizeof(");
2063 write_type(h
, e
->u
.tref
->ref
, NULL
, e
->u
.tref
->name
);
2074 if (brackets
) fprintf(h
, "(");
2075 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
2077 case EXPR_SHL
: fprintf(h
, " << "); break;
2078 case EXPR_SHR
: fprintf(h
, " >> "); break;
2079 case EXPR_MUL
: fprintf(h
, " * "); break;
2080 case EXPR_DIV
: fprintf(h
, " / "); break;
2081 case EXPR_ADD
: fprintf(h
, " + "); break;
2082 case EXPR_SUB
: fprintf(h
, " - "); break;
2083 case EXPR_AND
: fprintf(h
, " & "); break;
2084 case EXPR_OR
: fprintf(h
, " | "); break;
2087 write_struct_expr(h
, e
->u
.ext
, 1, fields
, structvar
);
2088 if (brackets
) fprintf(h
, ")");
2091 if (brackets
) fprintf(h
, "(");
2092 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
2094 write_struct_expr(h
, e
->u
.ext
, 1, fields
, structvar
);
2096 write_struct_expr(h
, e
->ext2
, 1, fields
, structvar
);
2097 if (brackets
) fprintf(h
, ")");
2103 void declare_stub_args( FILE *file
, int indent
, const func_t
*func
)
2105 int in_attr
, out_attr
;
2107 const var_t
*def
= func
->def
;
2110 /* declare return value '_RetVal' */
2111 if (!is_void(def
->type
, NULL
))
2113 print_file(file
, indent
, "");
2114 write_type(file
, def
->type
, def
, def
->tname
);
2115 fprintf(file
, " _RetVal;\n");
2121 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
2123 const expr_t
*size_is
= get_attrp(var
->attrs
, ATTR_SIZEIS
);
2124 int has_size
= size_is
&& (size_is
->type
!= EXPR_VOID
);
2125 int is_string
= is_attr(var
->attrs
, ATTR_STRING
);
2127 in_attr
= is_attr(var
->attrs
, ATTR_IN
);
2128 out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
2129 if (!out_attr
&& !in_attr
)
2132 if (!in_attr
&& !has_size
&& !is_string
)
2135 print_file(file
, indent
, "");
2136 write_type(file
, var
->type
, NULL
, var
->tname
);
2137 for (indirection
= 0; indirection
< var
->ptr_level
- 1; indirection
++)
2139 fprintf(file
, " _W%u;\n", i
++);
2142 print_file(file
, indent
, "");
2143 write_type(file
, var
->type
, var
, var
->tname
);
2145 write_name(file
, var
);
2146 write_array(file
, var
->array
, 0);
2147 fprintf(file
, ";\n");
2152 void assign_stub_out_args( FILE *file
, int indent
, const func_t
*func
)
2154 int in_attr
, out_attr
;
2157 const expr_t
*size_is
;
2163 LIST_FOR_EACH_ENTRY( var
, func
->args
, const var_t
, entry
)
2165 int is_string
= is_attr(var
->attrs
, ATTR_STRING
);
2166 size_is
= get_attrp(var
->attrs
, ATTR_SIZEIS
);
2167 has_size
= size_is
&& (size_is
->type
!= EXPR_VOID
);
2168 in_attr
= is_attr(var
->attrs
, ATTR_IN
);
2169 out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
2170 if (!out_attr
&& !in_attr
)
2175 print_file(file
, indent
, "");
2176 write_name(file
, var
);
2181 type_t
*type
= var
->type
;
2183 fprintf(file
, " = NdrAllocate(&_StubMsg, ");
2184 write_expr(file
, size_is
, 1);
2185 size
= get_type_memsize(type
);
2186 fprintf(file
, " * %u);\n", size
);
2188 else if (!is_string
)
2190 fprintf(file
, " = &_W%u;\n", i
);
2191 if (var
->ptr_level
> 1)
2192 print_file(file
, indent
, "_W%u = 0;\n", i
);
2200 fprintf(file
, "\n");
2204 int write_expr_eval_routines(FILE *file
, const char *iface
)
2207 struct expr_eval_routine
*eval
;
2208 unsigned short callback_offset
= 0;
2210 LIST_FOR_EACH_ENTRY(eval
, &expr_eval_routines
, struct expr_eval_routine
, entry
)
2214 print_file(file
, indent
, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
2215 iface
, eval
->structure
->name
, callback_offset
);
2216 print_file(file
, indent
, "{\n");
2218 print_file(file
, indent
, "struct %s *" STRUCT_EXPR_EVAL_VAR
" = (struct %s *)(pStubMsg->StackTop - %u);\n",
2219 eval
->structure
->name
, eval
->structure
->name
, eval
->structure_size
);
2220 fprintf(file
, "\n");
2221 print_file(file
, indent
, "pStubMsg->Offset = 0;\n"); /* FIXME */
2222 print_file(file
, indent
, "pStubMsg->MaxCount = (unsigned long)");
2223 write_struct_expr(file
, eval
->expr
, 1, eval
->structure
->fields
, STRUCT_EXPR_EVAL_VAR
);
2224 fprintf(file
, ";\n");
2226 print_file(file
, indent
, "}\n\n");
2232 void write_expr_eval_routine_list(FILE *file
, const char *iface
)
2234 struct expr_eval_routine
*eval
;
2235 struct expr_eval_routine
*cursor
;
2236 unsigned short callback_offset
= 0;
2238 fprintf(file
, "static const EXPR_EVAL ExprEvalRoutines[] =\n");
2239 fprintf(file
, "{\n");
2241 LIST_FOR_EACH_ENTRY_SAFE(eval
, cursor
, &expr_eval_routines
, struct expr_eval_routine
, entry
)
2243 print_file(file
, 1, "%s_%sExprEval_%04u,\n",
2244 iface
, eval
->structure
->name
, callback_offset
);
2247 list_remove(&eval
->entry
);
2251 fprintf(file
, "};\n\n");