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 expr_t
*array
);
63 static size_t fields_memsize(const var_t
*v
);
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
;
76 return a
->u
.lval
- b
->u
.lval
;
78 return strcmp(a
->u
.sval
, b
->u
.sval
);
80 ret
= compare_expr(a
->ref
, b
->ref
);
83 ret
= compare_expr(a
->u
.ext
, b
->u
.ext
);
86 return compare_expr(a
->ext2
, b
->ext2
);
95 ret
= compare_expr(a
->ref
, b
->ref
);
98 return compare_expr(a
->u
.ext
, b
->u
.ext
);
104 return compare_expr(a
->ref
, b
->ref
);
111 #define WRITE_FCTYPE(file, fctype, typestring_offset) \
114 fprintf(file, "/* %2u */\n", typestring_offset); \
115 print_file((file), 2, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
119 static int print_file(FILE *file
, int indent
, const char *format
, ...)
126 va_start(va
, format
);
127 for (i
= 0; i
< indent
; i
++)
129 r
= vfprintf(file
, format
, va
);
134 static inline int type_has_ref(const type_t
*type
)
136 return (type
->type
== 0 && type
->ref
);
139 static inline int is_base_type(unsigned char type
)
158 case RPC_FC_ERROR_STATUS_T
:
159 case RPC_FC_BIND_PRIMITIVE
:
167 static size_t write_procformatstring_var(FILE *file
, int indent
,
168 const var_t
*var
, int is_return
, unsigned int *type_offset
)
171 int ptr_level
= var
->ptr_level
;
172 const type_t
*type
= var
->type
;
174 int is_in
= is_attr(var
->attrs
, ATTR_IN
);
175 int is_out
= is_attr(var
->attrs
, ATTR_OUT
);
177 if (!is_in
&& !is_out
) is_in
= TRUE
;
179 if (ptr_level
== 0 && type_has_ref(type
))
182 if (ptr_level
== 0 && !var
->array
&& is_base_type(type
->type
))
185 print_file(file
, indent
, "0x53, /* FC_RETURN_PARAM_BASETYPE */\n");
187 print_file(file
, indent
, "0x4e, /* FC_IN_PARAM_BASETYPE */\n");
191 #define CASE_BASETYPE(fctype) \
193 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
194 size = 2; /* includes param type prefix */ \
197 CASE_BASETYPE(FC_BYTE
);
198 CASE_BASETYPE(FC_CHAR
);
199 CASE_BASETYPE(FC_WCHAR
);
200 CASE_BASETYPE(FC_USHORT
);
201 CASE_BASETYPE(FC_SHORT
);
202 CASE_BASETYPE(FC_ULONG
);
203 CASE_BASETYPE(FC_LONG
);
204 CASE_BASETYPE(FC_HYPER
);
205 CASE_BASETYPE(FC_IGNORE
);
206 CASE_BASETYPE(FC_USMALL
);
207 CASE_BASETYPE(FC_SMALL
);
208 CASE_BASETYPE(FC_FLOAT
);
209 CASE_BASETYPE(FC_DOUBLE
);
210 CASE_BASETYPE(FC_ERROR_STATUS_T
);
213 case RPC_FC_BIND_PRIMITIVE
:
214 print_file(file
, indent
, "0x%02x, /* FC_IGNORE */\n", RPC_FC_IGNORE
);
215 size
= 2; /* includes param type prefix */
219 error("Unknown/unsupported type: %s (0x%02x)\n", var
->name
, type
->type
);
226 print_file(file
, indent
, "0x52, /* FC_RETURN_PARAM */\n");
227 else if (is_in
&& is_out
)
228 print_file(file
, indent
, "0x50, /* FC_IN_OUT_PARAM */\n");
230 print_file(file
, indent
, "0x51, /* FC_OUT_PARAM */\n");
232 print_file(file
, indent
, "0x4d, /* FC_IN_PARAM */\n");
234 print_file(file
, indent
, "0x01,\n");
235 print_file(file
, indent
, "NdrFcShort(0x%x),\n", *type_offset
);
236 size
= 4; /* includes param type prefix */
238 *type_offset
+= get_size_typeformatstring_var(var
);
242 void write_procformatstring(FILE *file
, type_t
*iface
)
246 unsigned int type_offset
= 2;
248 print_file(file
, indent
, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
249 print_file(file
, indent
, "{\n");
251 print_file(file
, indent
, "0,\n");
252 print_file(file
, indent
, "{\n");
257 func_t
*func
= iface
->funcs
;
258 while (NEXT_LINK(func
)) func
= NEXT_LINK(func
);
259 for (; func
; func
= PREV_LINK(func
))
261 /* emit argument data */
265 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
268 write_procformatstring_var(file
, indent
, var
, FALSE
,
271 var
= PREV_LINK(var
);
275 /* emit return value data */
277 if (is_void(var
->type
, NULL
))
279 print_file(file
, indent
, "0x5b, /* FC_END */\n");
280 print_file(file
, indent
, "0x5c, /* FC_PAD */\n");
283 write_procformatstring_var(file
, indent
, var
, TRUE
,
288 print_file(file
, indent
, "0x0\n");
290 print_file(file
, indent
, "}\n");
292 print_file(file
, indent
, "};\n");
293 print_file(file
, indent
, "\n");
296 /* write conformance / variance descriptor */
297 static size_t write_conf_or_var_desc(FILE *file
, const func_t
*func
, const type_t
*structure
, const expr_t
*expr
)
299 unsigned char operator_type
= 0;
300 const char *operator_string
= "no operators";
301 const expr_t
*subexpr
= expr
;
302 unsigned char correlation_type
;
304 if (!file
) return 4; /* optimisation for sizing pass */
308 if (expr
->cval
> UCHAR_MAX
* (USHRT_MAX
+ 1) + USHRT_MAX
)
309 error("write_conf_or_var_desc: constant value %ld is greater than "
310 "the maximum constant size of %d\n", expr
->cval
,
311 UCHAR_MAX
* (USHRT_MAX
+ 1) + USHRT_MAX
);
313 print_file(file
, 2, "0x%x, /* Corr desc: constant, val = %ld */\n",
314 RPC_FC_CONSTANT_CONFORMANCE
, expr
->cval
);
315 print_file(file
, 2, "0x%x,\n", expr
->cval
& ~USHRT_MAX
);
316 print_file(file
, 2, "NdrFcShort(0x%x),\n", expr
->cval
& USHRT_MAX
);
321 switch (subexpr
->type
)
324 subexpr
= subexpr
->ref
;
325 operator_type
= RPC_FC_DEREFERENCE
;
326 operator_string
= "FC_DEREFERENCE";
329 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 2))
331 subexpr
= subexpr
->ref
;
332 operator_type
= RPC_FC_DIV_2
;
333 operator_string
= "FC_DIV_2";
337 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 2))
339 subexpr
= subexpr
->ref
;
340 operator_type
= RPC_FC_MULT_2
;
341 operator_string
= "FC_MULT_2";
345 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 1))
347 subexpr
= subexpr
->ref
;
348 operator_type
= RPC_FC_SUB_1
;
349 operator_string
= "FC_SUB_1";
353 if (subexpr
->u
.ext
->is_const
&& (subexpr
->u
.ext
->cval
== 1))
355 subexpr
= subexpr
->ref
;
356 operator_type
= RPC_FC_ADD_1
;
357 operator_string
= "FC_ADD_1";
364 if (subexpr
->type
== EXPR_IDENTIFIER
)
366 const type_t
*correlation_variable
= NULL
;
367 unsigned char param_type
= 0;
368 const char *param_type_string
= NULL
;
375 for (offset
= 0, var
= structure
->fields
; var
; var
= NEXT_LINK(var
))
377 offset
-= type_memsize(var
->type
, var
->ptr_level
, var
->array
);
378 if (!strcmp(var
->name
, subexpr
->u
.sval
))
380 correlation_variable
= var
->type
;
384 if (!correlation_variable
)
385 error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
388 correlation_type
= RPC_FC_NORMAL_CONFORMANCE
;
392 const var_t
*var
= func
->args
;
394 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
395 /* FIXME: not all stack variables are sizeof(void *) */
396 for (offset
= 0; var
; offset
+= sizeof(void *), var
= PREV_LINK(var
))
398 if (!strcmp(var
->name
, subexpr
->u
.sval
))
400 correlation_variable
= var
->type
;
404 if (!correlation_variable
)
405 error("write_conf_or_var_desc: couldn't find variable %s in function\n",
408 correlation_type
= RPC_FC_TOP_LEVEL_CONFORMANCE
;
411 while (type_has_ref(correlation_variable
))
412 correlation_variable
= correlation_variable
->ref
;
414 switch (correlation_variable
->type
)
418 param_type
= RPC_FC_SMALL
;
419 param_type_string
= "FC_SMALL";
423 param_type
= RPC_FC_USMALL
;
424 param_type_string
= "FC_USMALL";
428 param_type
= RPC_FC_SHORT
;
429 param_type_string
= "FC_SHORT";
432 param_type
= RPC_FC_USHORT
;
433 param_type_string
= "FC_USHORT";
436 param_type
= RPC_FC_LONG
;
437 param_type_string
= "FC_LONG";
440 param_type
= RPC_FC_ULONG
;
441 param_type_string
= "FC_ULONG";
444 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n",
445 correlation_variable
->type
);
448 print_file(file
, 2, "0x%x, /* Corr desc: %s%s */\n",
449 correlation_type
| param_type
,
450 correlation_type
== RPC_FC_TOP_LEVEL_CONFORMANCE
? "parameter, " : "",
452 print_file(file
, 2, "0x%x, /* %s */\n", operator_type
, operator_string
);
453 print_file(file
, 2, "NdrFcShort(0x%x), /* %soffset = %d */\n",
455 correlation_type
== RPC_FC_TOP_LEVEL_CONFORMANCE
? "x86 stack size / " : "",
460 unsigned int callback_offset
= 0;
464 struct expr_eval_routine
*eval
;
467 LIST_FOR_EACH_ENTRY(eval
, &expr_eval_routines
, struct expr_eval_routine
, entry
)
469 if (!strcmp(eval
->structure
->name
, structure
->name
) &&
470 !compare_expr(eval
->expr
, expr
))
480 eval
= xmalloc(sizeof(*eval
));
481 eval
->structure
= structure
;
482 eval
->structure_size
= fields_memsize(structure
->fields
);
484 list_add_tail(&expr_eval_routines
, &eval
->entry
);
487 correlation_type
= RPC_FC_NORMAL_CONFORMANCE
;
491 error("write_conf_or_var_desc: top-level callback conformance unimplemented\n");
492 correlation_type
= RPC_FC_TOP_LEVEL_CONFORMANCE
;
495 if (callback_offset
> USHRT_MAX
)
496 error("Maximum number of callback routines reached\n");
498 print_file(file
, 2, "0x%x, /* Corr desc: %s */\n",
500 correlation_type
== RPC_FC_TOP_LEVEL_CONFORMANCE
? "parameter" : "");
501 print_file(file
, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK
, "FC_CALLBACK");
502 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", callback_offset
, callback_offset
);
507 static size_t fields_memsize(const var_t
*v
)
510 const var_t
*first
= v
;
512 while (NEXT_LINK(v
)) v
= NEXT_LINK(v
);
514 size
+= type_memsize(v
->type
, v
->ptr_level
, v
->array
);
515 if (v
== first
) break;
521 static size_t type_memsize(const type_t
*t
, int ptr_level
, const expr_t
*array
)
526 return sizeof(void *);
529 return type_memsize(t
->ref
, 0 /* FIXME */, NULL
);
547 case RPC_FC_ERROR_STATUS_T
:
557 case RPC_FC_CVSTRUCT
:
558 case RPC_FC_CPSTRUCT
:
561 case RPC_FC_BOGUS_STRUCT
:
562 case RPC_FC_ENCAPSULATED_UNION
:
563 case RPC_FC_NON_ENCAPSULATED_UNION
:
564 size
= fields_memsize(t
->fields
);
567 error("type_memsize: Unknown type %d\n", t
->type
);
582 size_t get_type_memsize(const type_t
*type
)
584 return type_memsize(type
, 0, NULL
);
587 static int write_pointers(FILE *file
, const attr_t
*attrs
,
588 const type_t
*type
, int ptr_level
,
589 const expr_t
*array
, int level
,
590 size_t *typestring_offset
)
592 int pointers_written
= 0;
595 /* don't generate a pointer for first-level arrays since we want to
596 * descend into them to write their pointers, not stop here */
597 if ((level
== 0 || ptr_level
== 0) && is_array_type(attrs
, ptr_level
, array
))
599 return write_pointers(file
, NULL
, type
, 0, NULL
, level
+ 1, typestring_offset
);
604 /* FIXME: only general algorithm implemented, not the actual writing */
605 error("write_pointers: Writing type format string for pointer is unimplemented\n");
609 /* FIXME: search through all refs for pointers too */
610 while(type_has_ref(type
))
615 /* note: don't descend into complex structures or unions since these
616 * will always be generated as a separate type */
618 case RPC_FC_CVSTRUCT
:
619 case RPC_FC_CPSTRUCT
:
624 while (NEXT_LINK(v
)) v
= NEXT_LINK(v
);
625 for (; v
; v
= PREV_LINK(v
))
626 pointers_written
+= write_pointers(file
, v
->attrs
, v
->type
,
627 v
->ptr_level
, v
->array
,
638 return pointers_written
;
641 static size_t write_pointer_description(FILE *file
, const attr_t
*attrs
,
642 const type_t
*type
, int ptr_level
,
643 const expr_t
*array
, int level
,
644 size_t typestring_offset
)
649 /* don't generate a pointer for first-level arrays since we want to
650 * descend into them to write their pointers, not stop here */
651 if ((level
== 0 || ptr_level
== 0) && is_array_type(attrs
, ptr_level
, array
))
653 return write_pointer_description(file
, NULL
, type
, 0, NULL
,
654 level
+ 1, typestring_offset
);
659 /* FIXME: only general algorithm implemented, not the actual writing */
660 error("write_pointer_description: Writing pointer description is unimplemented\n");
664 /* FIXME: search through all refs for pointers too */
668 /* note: don't descend into complex structures or unions since these
669 * will always be generated as a separate type */
671 case RPC_FC_CVSTRUCT
:
672 case RPC_FC_CPSTRUCT
:
677 while (NEXT_LINK(v
)) v
= NEXT_LINK(v
);
678 for (; v
; v
= PREV_LINK(v
))
679 size
+= write_pointer_description(file
, v
->attrs
, v
->type
,
680 v
->ptr_level
, v
->array
,
694 static size_t write_string_tfs(FILE *file
, const attr_t
*attrs
,
695 const type_t
*type
, const expr_t
*array
,
696 const char *name
, size_t *typestring_offset
)
698 const expr_t
*size_is
= get_attrp(attrs
, ATTR_SIZEIS
);
699 int has_size
= size_is
&& (size_is
->type
!= EXPR_VOID
);
700 size_t start_offset
= *typestring_offset
;
701 unsigned char flags
= 0;
702 int pointer_type
= get_attrv(attrs
, ATTR_POINTERTYPE
);
704 pointer_type
= RPC_FC_RP
;
706 if (!get_attrp(attrs
, ATTR_SIZEIS
))
707 flags
|= RPC_FC_P_SIMPLEPOINTER
;
709 while (type_has_ref(type
))
712 if ((type
->type
!= RPC_FC_BYTE
) && (type
->type
!= RPC_FC_CHAR
) && (type
->type
!= RPC_FC_WCHAR
))
714 error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", type
->type
, name
);
718 print_file(file
, 2,"0x%x, 0x%x, /* %s%s */\n",
720 pointer_type
== RPC_FC_FP
? "FC_FP" : (pointer_type
== RPC_FC_UP
? "FC_UP" : "FC_RP"),
721 (flags
& RPC_FC_P_SIMPLEPOINTER
) ? " [simple_pointer]" : "");
722 *typestring_offset
+= 2;
724 if (!(flags
& RPC_FC_P_SIMPLEPOINTER
))
726 print_file(file
, 2, "NdrFcShort(0x2),\n");
727 *typestring_offset
+= 2;
730 if (array
&& array
->is_const
)
732 if (array
->cval
> USHRT_MAX
)
733 error("array size for parameter %s exceeds %d bytes by %ld bytes\n",
734 name
, USHRT_MAX
, array
->cval
- USHRT_MAX
);
736 if (type
->type
== RPC_FC_CHAR
)
737 WRITE_FCTYPE(file
, FC_CSTRING
, *typestring_offset
);
739 WRITE_FCTYPE(file
, FC_WSTRING
, *typestring_offset
);
740 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
741 *typestring_offset
+= 2;
743 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", array
->cval
, array
->cval
);
744 *typestring_offset
+= 2;
750 if (type
->type
== RPC_FC_CHAR
)
751 WRITE_FCTYPE(file
, FC_C_CSTRING
, *typestring_offset
);
753 WRITE_FCTYPE(file
, FC_C_WSTRING
, *typestring_offset
);
754 print_file(file
, 2, "0x%x, /* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED
);
755 *typestring_offset
+= 2;
757 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
, NULL
, size_is
);
763 if (type
->type
== RPC_FC_CHAR
)
764 WRITE_FCTYPE(file
, FC_C_CSTRING
, *typestring_offset
);
766 WRITE_FCTYPE(file
, FC_C_WSTRING
, *typestring_offset
);
767 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
768 *typestring_offset
+= 2;
774 static size_t write_array_tfs(FILE *file
, const attr_t
*attrs
,
775 const type_t
*type
, const expr_t
*array
,
776 const char *name
, size_t *typestring_offset
)
778 const expr_t
*length_is
= get_attrp(attrs
, ATTR_LENGTHIS
);
779 const expr_t
*size_is
= get_attrp(attrs
, ATTR_SIZEIS
);
780 int has_length
= length_is
&& (length_is
->type
!= EXPR_VOID
);
781 int has_size
= (size_is
&& (size_is
->type
!= EXPR_VOID
)) || !array
->is_const
;
783 int pointer_type
= get_attrv(attrs
, ATTR_POINTERTYPE
);
785 pointer_type
= RPC_FC_RP
;
787 print_file(file
, 2, "0x%x, 0x00, /* %s */\n",
789 pointer_type
== RPC_FC_FP
? "FC_FP" : (pointer_type
== RPC_FC_UP
? "FC_UP" : "FC_RP"));
790 print_file(file
, 2, "NdrFcShort(0x2),\n");
791 *typestring_offset
+= 4;
793 if (array
&& NEXT_LINK(array
)) /* multi-dimensional array */
795 error("write_array_tfs: Multi-dimensional arrays not implemented yet (param %s)\n", name
);
800 size_t pointer_start_offset
= *typestring_offset
;
803 if (write_pointers(file
, attrs
, type
, 0, array
, 0, typestring_offset
) > 0)
806 start_offset
= *typestring_offset
;
808 if (!has_length
&& !has_size
)
811 size_t size
= type_memsize(type
, 0, array
);
812 if (size
< USHRT_MAX
)
814 WRITE_FCTYPE(file
, FC_SMFARRAY
, *typestring_offset
);
816 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
818 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", size
, size
);
819 *typestring_offset
+= 4;
823 WRITE_FCTYPE(file
, FC_LGFARRAY
, *typestring_offset
);
825 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
827 print_file(file
, 2, "NdrFcLong(0x%x), /* %d */\n", size
, size
);
828 *typestring_offset
+= 6;
833 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
834 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
835 *typestring_offset
+= 2;
836 *typestring_offset
= write_pointer_description(file
, attrs
,
837 type
, 0, array
, 0, pointer_start_offset
);
838 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
839 *typestring_offset
+= 1;
842 print_file(file
, 2, "0x0, /* FIXME: write out conversion data */\n");
843 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
844 *typestring_offset
+= 2;
848 else if (has_length
&& !has_size
)
851 size_t element_size
= type_memsize(type
, 0, NULL
);
852 size_t elements
= array
->cval
;
853 size_t total_size
= element_size
* elements
;
855 if (total_size
< USHRT_MAX
)
857 WRITE_FCTYPE(file
, FC_SMVARRAY
, *typestring_offset
);
859 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
861 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", total_size
, total_size
);
862 /* number of elements */
863 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", elements
, elements
);
864 *typestring_offset
+= 6;
868 WRITE_FCTYPE(file
, FC_LGVARRAY
, *typestring_offset
);
870 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
872 print_file(file
, 2, "NdrFcLong(0x%x), /* %d */\n", total_size
, total_size
);
873 /* number of elements */
874 print_file(file
, 2, "NdrFcLong(0x%x), /* %d */\n", elements
, elements
);
875 *typestring_offset
+= 10;
878 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", element_size
, element_size
);
879 *typestring_offset
+= 2;
881 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
887 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
888 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
889 *typestring_offset
+= 2;
890 *typestring_offset
+= write_pointer_description(file
, attrs
,
891 type
, 0, array
, 0, pointer_start_offset
);
892 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
893 *typestring_offset
+= 1;
896 print_file(file
, 2, "0x0, /* FIXME: write out conversion data */\n");
897 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
898 *typestring_offset
+= 2;
902 else if (!has_length
&& has_size
)
904 /* conformant array */
905 size_t element_size
= type_memsize(type
, 0, NULL
);
907 WRITE_FCTYPE(file
, FC_CARRAY
, *typestring_offset
);
909 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
911 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", element_size
, element_size
);
912 *typestring_offset
+= 4;
914 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
916 size_is
? size_is
: array
);
920 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
921 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
922 *typestring_offset
+= 2;
923 *typestring_offset
+= write_pointer_description(file
, attrs
,
924 type
, 0, array
, 0, pointer_start_offset
);
925 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
926 *typestring_offset
+= 1;
929 print_file(file
, 2, "0x%x, /* FIXME: write out conversion data */\n", type
->type
);
930 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
931 *typestring_offset
+= 2;
937 /* conformant varying array */
938 size_t element_size
= type_memsize(type
, 0, NULL
);
940 WRITE_FCTYPE(file
, FC_CVARRAY
, *typestring_offset
);
942 print_file(file
, 2, "0x%x, /* 0 */\n", 0);
944 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", element_size
, element_size
);
945 *typestring_offset
+= 4;
947 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
949 size_is
? size_is
: array
);
950 *typestring_offset
+= write_conf_or_var_desc(file
, current_func
,
956 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
957 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
958 *typestring_offset
+= 2;
959 *typestring_offset
+= write_pointer_description(file
, attrs
,
960 type
, 0, array
, 0, pointer_start_offset
);
961 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
962 *typestring_offset
+= 1;
965 print_file(file
, 2, "0x0, /* FIXME: write out conversion data */\n");
966 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
967 *typestring_offset
+= 2;
974 static const var_t
*find_array_or_string_in_struct(const type_t
*type
)
976 /* last field is the first in the fields linked list */
977 const var_t
*last_field
= type
->fields
;
978 if (is_array_type(last_field
->attrs
, last_field
->ptr_level
, last_field
->array
))
981 assert((last_field
->type
->type
== RPC_FC_CSTRUCT
) ||
982 (last_field
->type
->type
== RPC_FC_CPSTRUCT
) ||
983 (last_field
->type
->type
== RPC_FC_CVSTRUCT
));
985 return find_array_or_string_in_struct(last_field
->type
);
988 static size_t write_struct_members(FILE *file
, const type_t
*type
)
990 size_t typestring_size
= 0;
993 field
= type
->fields
;
994 while (NEXT_LINK(field
)) field
= NEXT_LINK(field
);
995 for (; field
; field
= PREV_LINK(field
))
997 if (is_base_type(field
->type
->type
))
999 switch (field
->type
->type
)
1001 #define CASE_BASETYPE(fctype) \
1002 case RPC_##fctype: \
1003 print_file(file, 2, "0x%02x,\t\t/* " #fctype " */\n", RPC_##fctype); \
1004 typestring_size++; \
1006 CASE_BASETYPE(FC_BYTE
);
1007 CASE_BASETYPE(FC_CHAR
);
1008 CASE_BASETYPE(FC_SMALL
);
1009 CASE_BASETYPE(FC_USMALL
);
1010 CASE_BASETYPE(FC_WCHAR
);
1011 CASE_BASETYPE(FC_SHORT
);
1012 CASE_BASETYPE(FC_USHORT
);
1013 CASE_BASETYPE(FC_LONG
);
1014 CASE_BASETYPE(FC_ULONG
);
1015 CASE_BASETYPE(FC_FLOAT
);
1016 CASE_BASETYPE(FC_HYPER
);
1017 CASE_BASETYPE(FC_DOUBLE
);
1018 CASE_BASETYPE(FC_ENUM16
);
1019 CASE_BASETYPE(FC_ENUM32
);
1020 CASE_BASETYPE(FC_IGNORE
);
1021 CASE_BASETYPE(FC_ERROR_STATUS_T
);
1024 #undef CASE_BASETYPE
1028 error("Unsupported member type 0x%x\n", field
->type
->type
);
1031 if (typestring_size
% 1)
1033 print_file(file
, 2, "0x%x,\t\t/* FC_PAD */\n", RPC_FC_PAD
);
1037 print_file(file
, 2, "0x%x,\t\t/* FC_END */\n", RPC_FC_END
);
1040 return typestring_size
;
1043 static size_t write_struct_tfs(FILE *file
, const type_t
*type
,
1044 const char *name
, size_t *typestring_offset
)
1048 size_t start_offset
;
1049 size_t array_offset
;
1050 size_t pointer_offset
;
1055 case RPC_FC_PSTRUCT
:
1056 total_size
= type_memsize(type
, 0, NULL
);
1058 if (total_size
> USHRT_MAX
)
1059 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1060 name
, USHRT_MAX
, total_size
- USHRT_MAX
);
1062 if (type
->type
== RPC_FC_PSTRUCT
)
1064 pointer_offset
= *typestring_offset
;
1065 write_pointers(file
, NULL
, type
, 0, NULL
, 0, typestring_offset
);
1067 else pointer_offset
= 0; /* silence warning */
1069 start_offset
= *typestring_offset
;
1070 if (type
->type
== RPC_FC_STRUCT
)
1071 WRITE_FCTYPE(file
, FC_STRUCT
, *typestring_offset
);
1073 WRITE_FCTYPE(file
, FC_PSTRUCT
, *typestring_offset
);
1075 print_file(file
, 2, "0x3,\n"); /* FIXME */
1077 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", total_size
, total_size
);
1078 *typestring_offset
+= 4;
1080 if (type
->type
== RPC_FC_PSTRUCT
)
1082 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
1083 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
1084 *typestring_offset
+= 2;
1085 *typestring_offset
+= write_pointer_description(file
, NULL
,
1086 type
, 0, NULL
, 0, pointer_offset
);
1087 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1088 *typestring_offset
+= 1;
1092 *typestring_offset
+= write_struct_members(file
, type
);
1093 return start_offset
;
1094 case RPC_FC_CSTRUCT
:
1095 case RPC_FC_CPSTRUCT
:
1096 total_size
= type_memsize(type
, 0, NULL
);
1098 if (total_size
> USHRT_MAX
)
1099 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1100 name
, USHRT_MAX
, total_size
- USHRT_MAX
);
1102 array
= find_array_or_string_in_struct(type
);
1103 current_structure
= type
;
1104 array_offset
= write_array_tfs(file
, array
->attrs
, array
->type
,
1105 array
->array
, array
->name
,
1107 current_structure
= NULL
;
1109 if (type
->type
== RPC_FC_CPSTRUCT
)
1111 pointer_offset
= *typestring_offset
;
1112 write_pointers(file
, NULL
, type
, 0, NULL
, 0, typestring_offset
);
1114 else pointer_offset
= 0; /* silence warning */
1116 start_offset
= *typestring_offset
;
1117 if (type
->type
== RPC_FC_CSTRUCT
)
1118 WRITE_FCTYPE(file
, FC_CSTRUCT
, *typestring_offset
);
1120 WRITE_FCTYPE(file
, FC_CPSTRUCT
, *typestring_offset
);
1122 print_file(file
, 2, "0x0,\n");
1124 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", total_size
, total_size
);
1125 *typestring_offset
+= 4;
1126 print_file(file
, 2, "NdrFcShort(0x%x), /* offset = %d (%u) */\n",
1127 array_offset
- *typestring_offset
,
1128 array_offset
- *typestring_offset
,
1130 *typestring_offset
+= 2;
1132 if (type
->type
== RPC_FC_CPSTRUCT
)
1134 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
1135 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
1136 *typestring_offset
+= 2;
1137 *typestring_offset
+= write_pointer_description(file
, NULL
,
1138 type
, 0, NULL
, 0, pointer_offset
);
1139 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1140 *typestring_offset
+= 1;
1143 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1144 *typestring_offset
+= 1;
1146 return start_offset
;
1147 case RPC_FC_CVSTRUCT
:
1148 total_size
= type_memsize(type
, 0, NULL
);
1150 if (total_size
> USHRT_MAX
)
1151 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1152 name
, USHRT_MAX
, total_size
- USHRT_MAX
);
1154 array
= find_array_or_string_in_struct(type
);
1155 current_structure
= type
;
1156 if (is_attr(array
->attrs
, ATTR_STRING
))
1157 array_offset
= write_string_tfs(file
, array
->attrs
, array
->type
,
1158 array
->array
, array
->name
,
1161 array_offset
= write_array_tfs(file
, array
->attrs
, array
->type
,
1162 array
->array
, array
->name
,
1164 current_structure
= NULL
;
1166 pointer_offset
= *typestring_offset
;
1167 if (!write_pointers(file
, NULL
, type
, 0, NULL
, 0, typestring_offset
))
1170 start_offset
= *typestring_offset
;
1171 WRITE_FCTYPE(file
, FC_CVSTRUCT
, *typestring_offset
);
1173 print_file(file
, 2, "0x0,\n");
1175 print_file(file
, 2, "NdrFcShort(0x%x), /* %u */\n", total_size
, total_size
);
1176 *typestring_offset
+= 4;
1177 print_file(file
, 2, "NdrFcShort(0x%x), /* offset = %d (%u) */\n",
1178 array_offset
- *typestring_offset
,
1179 array_offset
- *typestring_offset
,
1181 *typestring_offset
+= 2;
1183 if (pointer_offset
!= 0)
1185 print_file(file
, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP
);
1186 print_file(file
, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD
);
1187 *typestring_offset
+= 2;
1188 *typestring_offset
+= write_pointer_description(file
, NULL
,
1189 type
, 0, NULL
, 0, pointer_offset
);
1190 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1191 *typestring_offset
+= 1;
1194 print_file(file
, 2, "0x%x, /* FC_END */\n", RPC_FC_END
);
1195 *typestring_offset
+= 1;
1197 return start_offset
;
1199 error("write_struct_tfs: Unimplemented for type 0x%x\n", type
->type
);
1200 return *typestring_offset
;
1204 static void write_pointer_only_tfs(FILE *file
, const attr_t
*attrs
, size_t offset
, size_t *typeformat_offset
)
1206 int in_attr
, out_attr
;
1207 unsigned char flags
= 0;
1208 int pointer_type
= get_attrv(attrs
, ATTR_POINTERTYPE
);
1209 if (!pointer_type
) pointer_type
= RPC_FC_RP
;
1210 in_attr
= is_attr(attrs
, ATTR_IN
);
1211 out_attr
= is_attr(attrs
, ATTR_OUT
);
1212 if (!in_attr
&& !out_attr
) in_attr
= 1;
1214 if (out_attr
&& !in_attr
&& pointer_type
== RPC_FC_RP
)
1217 print_file(file
, 2, "0x%x, 0x%x,\t\t/* %s%s */\n",
1220 pointer_type
== RPC_FC_FP
? "FC_FP" : (pointer_type
== RPC_FC_UP
? "FC_UP" : "FC_RP"),
1221 (flags
& 0x04) ? " [allocated_on_stack]" : "");
1222 print_file(file
, 2, "NdrFcShort(0x%x), /* %d */\n", offset
, offset
);
1223 *typeformat_offset
+= 4;
1226 static size_t write_union_tfs(FILE *file
, const attr_t
*attrs
,
1227 const type_t
*type
, const char *name
,
1228 size_t *typeformat_offset
)
1230 error("write_union_tfs: Unimplemented\n");
1231 return *typeformat_offset
;
1234 static size_t write_typeformatstring_var(FILE *file
, int indent
,
1235 const var_t
*var
, size_t *typeformat_offset
)
1237 const type_t
*type
= var
->type
;
1238 int ptr_level
= var
->ptr_level
;
1240 chat("write_typeformatstring_var: %s\n", var
->name
);
1244 chat("write_typeformatstring: type->type = 0x%x, type->name = %s, ptr_level = %d\n", type
->type
, type
->name
, ptr_level
);
1246 if (is_string_type(var
->attrs
, ptr_level
, var
->array
))
1247 return write_string_tfs(file
, var
->attrs
, type
, var
->array
, var
->name
, typeformat_offset
);
1249 if (is_array_type(var
->attrs
, ptr_level
, var
->array
))
1250 return write_array_tfs(file
, var
->attrs
, type
, var
->array
, var
->name
, typeformat_offset
);
1254 /* follow reference if the type has one */
1255 if (type_has_ref(type
))
1258 /* FIXME: get new ptr_level from type */
1262 /* basic types don't need a type format string */
1263 if (is_base_type(type
->type
))
1269 case RPC_FC_PSTRUCT
:
1270 case RPC_FC_CSTRUCT
:
1271 case RPC_FC_CPSTRUCT
:
1272 case RPC_FC_CVSTRUCT
:
1273 case RPC_FC_BOGUS_STRUCT
:
1274 return write_struct_tfs(file
, type
, var
->name
, typeformat_offset
);
1275 case RPC_FC_ENCAPSULATED_UNION
:
1276 case RPC_FC_NON_ENCAPSULATED_UNION
:
1277 return write_union_tfs(file
, var
->attrs
, type
, var
->name
, typeformat_offset
);
1279 case RPC_FC_BIND_PRIMITIVE
:
1283 error("write_typeformatstring_var: Unsupported type 0x%x for variable %s\n", type
->type
, var
->name
);
1286 else if (ptr_level
== 1 && !type_has_ref(type
))
1288 size_t start_offset
= *typeformat_offset
;
1289 int in_attr
= is_attr(var
->attrs
, ATTR_IN
);
1290 int out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
1291 int pointer_type
= get_attrv(var
->attrs
, ATTR_POINTERTYPE
);
1292 if (!pointer_type
) pointer_type
= RPC_FC_RP
;
1294 /* special case for pointers to base types */
1297 #define CASE_BASETYPE(fctype) \
1298 case RPC_##fctype: \
1299 print_file(file, indent, "0x%x, 0x%x, /* %s %s[simple_pointer] */\n", \
1301 (!in_attr && out_attr) ? 0x0C : 0x08, \
1302 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"), \
1303 (!in_attr && out_attr) ? "[allocated_on_stack] " : ""); \
1304 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
1305 print_file(file, indent, "0x5c, /* FC_PAD */\n"); \
1306 *typeformat_offset += 4; \
1308 CASE_BASETYPE(FC_BYTE
);
1309 CASE_BASETYPE(FC_CHAR
);
1310 CASE_BASETYPE(FC_SMALL
);
1311 CASE_BASETYPE(FC_USMALL
);
1312 CASE_BASETYPE(FC_WCHAR
);
1313 CASE_BASETYPE(FC_SHORT
);
1314 CASE_BASETYPE(FC_USHORT
);
1315 CASE_BASETYPE(FC_LONG
);
1316 CASE_BASETYPE(FC_ULONG
);
1317 CASE_BASETYPE(FC_FLOAT
);
1318 CASE_BASETYPE(FC_HYPER
);
1319 CASE_BASETYPE(FC_DOUBLE
);
1320 CASE_BASETYPE(FC_ENUM16
);
1321 CASE_BASETYPE(FC_ENUM32
);
1322 CASE_BASETYPE(FC_IGNORE
);
1323 CASE_BASETYPE(FC_ERROR_STATUS_T
);
1329 assert(ptr_level
> 0);
1332 fprintf(file
, "/* %2u */\n", *typeformat_offset
);
1333 write_pointer_only_tfs(file
, var
->attrs
, 2, typeformat_offset
);
1340 void write_typeformatstring(FILE *file
, type_t
*iface
)
1344 size_t typeformat_offset
;
1346 print_file(file
, indent
, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
1347 print_file(file
, indent
, "{\n");
1349 print_file(file
, indent
, "0,\n");
1350 print_file(file
, indent
, "{\n");
1352 print_file(file
, indent
, "NdrFcShort(0x0),\n");
1353 typeformat_offset
= 2;
1357 func_t
*func
= iface
->funcs
;
1358 while (NEXT_LINK(func
)) func
= NEXT_LINK(func
);
1359 for (; func
; func
= PREV_LINK(func
))
1361 current_func
= func
;
1365 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
1368 write_typeformatstring_var(file
, indent
, var
,
1369 &typeformat_offset
);
1370 var
= PREV_LINK(var
);
1376 print_file(file
, indent
, "0x0\n");
1378 print_file(file
, indent
, "}\n");
1380 print_file(file
, indent
, "};\n");
1381 print_file(file
, indent
, "\n");
1384 static unsigned int get_required_buffer_size_type(
1385 const type_t
*type
, int ptr_level
, const expr_t
*array
,
1386 const char *name
, unsigned int *alignment
)
1389 if (ptr_level
== 0 && !array
&& !type_has_ref(type
))
1409 case RPC_FC_ERROR_STATUS_T
:
1419 case RPC_FC_BIND_PRIMITIVE
:
1426 for (field
= type
->fields
; field
; field
= NEXT_LINK(field
))
1428 unsigned int alignment
;
1429 size
+= get_required_buffer_size_type(
1430 field
->type
, field
->ptr_level
, field
->array
, field
->name
,
1437 error("get_required_buffer_size: Unknown/unsupported type: %s (0x%02x)\n", name
, type
->type
);
1441 if (ptr_level
== 0 && type_has_ref(type
))
1442 return get_required_buffer_size_type(type
->ref
, 0 /* FIXME */, array
, name
, alignment
);
1446 unsigned int get_required_buffer_size(const var_t
*var
, unsigned int *alignment
, enum pass pass
)
1448 expr_t
*size_is
= get_attrp(var
->attrs
, ATTR_SIZEIS
);
1449 int has_size
= (size_is
&& (size_is
->type
!= EXPR_VOID
));
1450 int in_attr
= is_attr(var
->attrs
, ATTR_IN
);
1451 int out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
1453 if (!in_attr
&& !out_attr
)
1458 if (pass
== PASS_OUT
)
1460 if (out_attr
&& var
->ptr_level
> 0)
1462 type_t
*type
= var
->type
;
1463 while (type
->type
== 0 && type
->ref
)
1466 if (type
->type
== RPC_FC_STRUCT
)
1469 unsigned int size
= 36;
1470 for (field
= type
->fields
; field
; field
= NEXT_LINK(field
))
1473 size
+= get_required_buffer_size_type(
1474 field
->type
, field
->ptr_level
, field
->array
, field
->name
,
1484 if ((!out_attr
|| in_attr
) && !has_size
&& !is_attr(var
->attrs
, ATTR_STRING
) && !var
->array
)
1486 if (var
->ptr_level
> 0 || (var
->ptr_level
== 0 && type_has_ref(var
->type
)))
1488 type_t
*type
= var
->type
;
1489 while (type
->type
== 0 && type
->ref
)
1492 if (is_base_type(type
->type
))
1496 else if (type
->type
== RPC_FC_STRUCT
)
1498 unsigned int size
= 36;
1500 for (field
= type
->fields
; field
; field
= NEXT_LINK(field
))
1503 size
+= get_required_buffer_size_type(
1504 field
->type
, field
->ptr_level
, field
->array
, field
->name
,
1512 return get_required_buffer_size_type(var
->type
, var
->ptr_level
, var
->array
, var
->name
, alignment
);
1516 static void print_phase_function(FILE *file
, int indent
, const char *type
,
1517 enum remoting_phase phase
,
1518 const char *varname
, unsigned int type_offset
)
1520 const char *function
;
1523 case PHASE_BUFFERSIZE
:
1524 function
= "BufferSize";
1527 function
= "Marshall";
1529 case PHASE_UNMARSHAL
:
1530 function
= "Unmarshall";
1540 print_file(file
, indent
, "Ndr%s%s(\n", type
, function
);
1542 print_file(file
, indent
, "&_StubMsg,\n");
1543 print_file(file
, indent
, "%s%s,\n",
1544 (phase
== PHASE_UNMARSHAL
) ? "(unsigned char **)&" : "(unsigned char *)",
1546 print_file(file
, indent
, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n",
1547 type_offset
, (phase
== PHASE_UNMARSHAL
) ? "," : ");");
1548 if (phase
== PHASE_UNMARSHAL
)
1549 print_file(file
, indent
, "0);\n");
1553 void print_phase_basetype(FILE *file
, int indent
, enum remoting_phase phase
,
1554 enum pass pass
, const var_t
*var
,
1555 const char *varname
)
1557 const type_t
*type
= var
->type
;
1559 unsigned int alignment
= 0;
1561 /* no work to do for other phases, buffer sizing is done elsewhere */
1562 if (phase
!= PHASE_MARSHAL
&& phase
!= PHASE_UNMARSHAL
)
1565 while (type_has_ref(type
))
1588 case RPC_FC_ERROR_STATUS_T
:
1600 case RPC_FC_BIND_PRIMITIVE
:
1601 /* no marshalling needed */
1605 error("print_phase_basetype: Unsupported type: %s (0x%02x, ptr_level: 0)\n", var
->name
, type
->type
);
1609 print_file(file
, indent
, "_StubMsg.Buffer = (unsigned char *)(((long)_StubMsg.Buffer + %u) & ~0x%x);\n",
1610 alignment
- 1, alignment
- 1);
1612 if (phase
== PHASE_MARSHAL
)
1614 print_file(file
, indent
, "*(");
1615 write_type(file
, var
->type
, NULL
, var
->tname
);
1617 fprintf(file
, " *)_StubMsg.Buffer = *");
1619 fprintf(file
, " *)_StubMsg.Buffer = ");
1620 fprintf(file
, varname
);
1621 fprintf(file
, ";\n");
1623 else if (phase
== PHASE_UNMARSHAL
)
1625 if (pass
== PASS_IN
|| pass
== PASS_RETURN
)
1626 print_file(file
, indent
, "");
1628 print_file(file
, indent
, "*");
1629 fprintf(file
, varname
);
1630 if (pass
== PASS_IN
&& var
->ptr_level
)
1631 fprintf(file
, " = (");
1633 fprintf(file
, " = *(");
1634 write_type(file
, var
->type
, NULL
, var
->tname
);
1635 fprintf(file
, " *)_StubMsg.Buffer;\n");
1638 print_file(file
, indent
, "_StubMsg.Buffer += sizeof(");
1639 write_type(file
, var
->type
, NULL
, var
->tname
);
1640 fprintf(file
, ");\n");
1643 /* returns whether the MaxCount, Offset or ActualCount members need to be
1644 * filled in for the specified phase */
1645 static inline int is_size_needed_for_phase(enum remoting_phase phase
)
1647 return (phase
!= PHASE_UNMARSHAL
);
1650 void write_remoting_arguments(FILE *file
, int indent
, const func_t
*func
,
1651 unsigned int *type_offset
, enum pass pass
,
1652 enum remoting_phase phase
)
1654 const expr_t
*length_is
;
1655 const expr_t
*size_is
;
1656 int in_attr
, out_attr
, has_length
, has_size
, pointer_type
;
1663 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
1664 for (; var
; *type_offset
+= get_size_typeformatstring_var(var
), var
= PREV_LINK(var
))
1666 const type_t
*type
= var
->type
;
1667 length_is
= get_attrp(var
->attrs
, ATTR_LENGTHIS
);
1668 size_is
= get_attrp(var
->attrs
, ATTR_SIZEIS
);
1669 has_length
= length_is
&& (length_is
->type
!= EXPR_VOID
);
1670 has_size
= (size_is
&& (size_is
->type
!= EXPR_VOID
)) || (var
->array
&& !var
->array
->is_const
);
1672 pointer_type
= get_attrv(var
->attrs
, ATTR_POINTERTYPE
);
1674 pointer_type
= RPC_FC_RP
;
1676 in_attr
= is_attr(var
->attrs
, ATTR_IN
);
1677 out_attr
= is_attr(var
->attrs
, ATTR_OUT
);
1678 if (!in_attr
&& !out_attr
)
1695 while (type_has_ref(type
))
1698 if (is_string_type(var
->attrs
, var
->ptr_level
, var
->array
))
1700 if (var
->array
&& var
->array
->is_const
)
1701 print_phase_function(file
, indent
, "NonConformantString", phase
, var
->name
, *type_offset
);
1704 if (size_is
&& is_size_needed_for_phase(phase
))
1706 print_file(file
, indent
, "_StubMsg.MaxCount = (unsigned long)");
1707 write_expr(file
, size_is
, 1);
1708 fprintf(file
, ";\n");
1711 if ((phase
== PHASE_FREE
) || (pointer_type
== RPC_FC_UP
))
1712 print_phase_function(file
, indent
, "Pointer", phase
, var
->name
, *type_offset
);
1714 print_phase_function(file
, indent
, "ConformantString", phase
, var
->name
,
1715 *type_offset
+ (has_size
? 4 : 2));
1718 else if (is_array_type(var
->attrs
, var
->ptr_level
, var
->array
))
1720 const char *array_type
;
1722 if (var
->array
&& NEXT_LINK(var
->array
)) /* multi-dimensional array */
1723 array_type
= "ComplexArray";
1726 if (!has_length
&& !has_size
)
1727 array_type
= "FixedArray";
1728 else if (has_length
&& !has_size
)
1730 if (is_size_needed_for_phase(phase
))
1732 print_file(file
, indent
, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1733 print_file(file
, indent
, "_StubMsg.ActualCount = (unsigned long)");
1734 write_expr(file
, length_is
, 1);
1735 fprintf(file
, ";\n\n");
1737 array_type
= "VaryingArray";
1739 else if (!has_length
&& has_size
)
1741 if (is_size_needed_for_phase(phase
) && phase
!= PHASE_FREE
)
1743 print_file(file
, indent
, "_StubMsg.MaxCount = (unsigned long)");
1744 write_expr(file
, size_is
? size_is
: var
->array
, 1);
1745 fprintf(file
, ";\n\n");
1747 array_type
= "ConformantArray";
1751 if (is_size_needed_for_phase(phase
))
1753 print_file(file
, indent
, "_StubMsg.MaxCount = (unsigned long)");
1754 write_expr(file
, size_is
? size_is
: var
->array
, 1);
1755 fprintf(file
, ";\n");
1756 print_file(file
, indent
, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1757 print_file(file
, indent
, "_StubMsg.ActualCount = (unsigned long)");
1758 write_expr(file
, length_is
, 1);
1759 fprintf(file
, ";\n\n");
1761 array_type
= "ConformantVaryingArray";
1765 if (!in_attr
&& phase
== PHASE_FREE
)
1767 print_file(file
, indent
, "if (%s)\n", var
->name
);
1769 print_file(file
, indent
, "_StubMsg.pfnFree(%s);\n", var
->name
);
1771 else if (phase
!= PHASE_FREE
)
1773 if (pointer_type
== RPC_FC_UP
)
1774 print_phase_function(file
, indent
, "Pointer", phase
, var
->name
, *type_offset
);
1776 print_phase_function(file
, indent
, array_type
, phase
, var
->name
, *type_offset
+ 4);
1779 else if (var
->ptr_level
== 0 && is_base_type(type
->type
))
1781 print_phase_basetype(file
, indent
, phase
, pass
, var
, var
->name
);
1783 else if (var
->ptr_level
== 0)
1785 const char *ndrtype
;
1790 ndrtype
= "SimpleStruct";
1792 case RPC_FC_CSTRUCT
:
1793 case RPC_FC_CPSTRUCT
:
1794 ndrtype
= "ConformantStruct";
1796 case RPC_FC_CVSTRUCT
:
1797 ndrtype
= "ConformantVaryingStruct";
1799 case RPC_FC_BOGUS_STRUCT
:
1800 ndrtype
= "ComplexStruct";
1803 error("write_remoting_arguments: Unsupported type: %s (0x%02x, ptr_level: %d)\n",
1804 var
->name
, type
->type
, var
->ptr_level
);
1808 print_phase_function(file
, indent
, ndrtype
, phase
, var
->name
, *type_offset
);
1812 if ((var
->ptr_level
== 1) && (pointer_type
== RPC_FC_RP
) && is_base_type(type
->type
))
1814 print_phase_basetype(file
, indent
, phase
, pass
, var
, var
->name
);
1816 else if ((var
->ptr_level
== 1) && (pointer_type
== RPC_FC_RP
) && (type
->type
== RPC_FC_STRUCT
))
1818 if (phase
!= PHASE_BUFFERSIZE
&& phase
!= PHASE_FREE
)
1819 print_phase_function(file
, indent
, "SimpleStruct", phase
, var
->name
, *type_offset
+ 4);
1823 print_phase_function(file
, indent
, "Pointer", phase
, var
->name
, *type_offset
);
1826 fprintf(file
, "\n");
1831 size_t get_size_procformatstring_var(const var_t
*var
)
1833 unsigned int type_offset
= 2;
1834 return write_procformatstring_var(NULL
, 0, var
, FALSE
, &type_offset
);
1838 size_t get_size_typeformatstring_var(const var_t
*var
)
1840 size_t type_offset
= 0;
1841 write_typeformatstring_var(NULL
, 0, var
, &type_offset
);
1845 size_t get_size_procformatstring(const type_t
*iface
)
1853 func
= iface
->funcs
;
1854 while (NEXT_LINK(func
)) func
= NEXT_LINK(func
);
1857 /* argument list size */
1861 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
1864 size
+= get_size_procformatstring_var(var
);
1865 var
= PREV_LINK(var
);
1869 /* return value size */
1870 size
+= 2; /* FIXME: determine real size */
1871 func
= PREV_LINK(func
);
1877 size_t get_size_typeformatstring(const type_t
*iface
)
1885 func
= iface
->funcs
;
1886 while (NEXT_LINK(func
)) func
= NEXT_LINK(func
);
1889 /* argument list size */
1893 while (NEXT_LINK(var
)) var
= NEXT_LINK(var
);
1896 size
+= get_size_typeformatstring_var(var
);
1897 var
= PREV_LINK(var
);
1901 func
= PREV_LINK(func
);
1907 static void write_struct_expr(FILE *h
, const expr_t
*e
, int brackets
,
1908 const var_t
*fields
, const char *structvar
)
1914 fprintf(h
, "%ld", e
->u
.lval
);
1917 fprintf(h
, "0x%lx", e
->u
.lval
);
1919 case EXPR_IDENTIFIER
:
1922 for (field
= fields
; field
; field
= NEXT_LINK(field
))
1924 if (!strcmp(e
->u
.sval
, field
->name
))
1926 fprintf(h
, "%s->%s", structvar
, e
->u
.sval
);
1930 if (!field
) error("no field found for identifier %s\n", e
->u
.sval
);
1935 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
1939 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
1943 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
1947 write_type(h
, e
->u
.tref
->ref
, NULL
, e
->u
.tref
->name
);
1949 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
1952 fprintf(h
, "sizeof(");
1953 write_type(h
, e
->u
.tref
->ref
, NULL
, e
->u
.tref
->name
);
1964 if (brackets
) fprintf(h
, "(");
1965 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
1967 case EXPR_SHL
: fprintf(h
, " << "); break;
1968 case EXPR_SHR
: fprintf(h
, " >> "); break;
1969 case EXPR_MUL
: fprintf(h
, " * "); break;
1970 case EXPR_DIV
: fprintf(h
, " / "); break;
1971 case EXPR_ADD
: fprintf(h
, " + "); break;
1972 case EXPR_SUB
: fprintf(h
, " - "); break;
1973 case EXPR_AND
: fprintf(h
, " & "); break;
1974 case EXPR_OR
: fprintf(h
, " | "); break;
1977 write_struct_expr(h
, e
->u
.ext
, 1, fields
, structvar
);
1978 if (brackets
) fprintf(h
, ")");
1981 if (brackets
) fprintf(h
, "(");
1982 write_struct_expr(h
, e
->ref
, 1, fields
, structvar
);
1984 write_struct_expr(h
, e
->u
.ext
, 1, fields
, structvar
);
1986 write_struct_expr(h
, e
->ext2
, 1, fields
, structvar
);
1987 if (brackets
) fprintf(h
, ")");
1992 int write_expr_eval_routines(FILE *file
, const char *iface
)
1995 struct expr_eval_routine
*eval
;
1996 unsigned short callback_offset
= 0;
1998 LIST_FOR_EACH_ENTRY(eval
, &expr_eval_routines
, struct expr_eval_routine
, entry
)
2002 print_file(file
, indent
, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
2003 iface
, eval
->structure
->name
, callback_offset
);
2004 print_file(file
, indent
, "{\n");
2006 print_file(file
, indent
, "struct %s *" STRUCT_EXPR_EVAL_VAR
" = (struct %s *)(pStubMsg->StackTop - %u);\n",
2007 eval
->structure
->name
, eval
->structure
->name
, eval
->structure_size
);
2008 fprintf(file
, "\n");
2009 print_file(file
, indent
, "pStubMsg->Offset = 0;\n"); /* FIXME */
2010 print_file(file
, indent
, "pStubMsg->MaxCount = (unsigned long)");
2011 write_struct_expr(file
, eval
->expr
, 1, eval
->structure
->fields
, STRUCT_EXPR_EVAL_VAR
);
2012 fprintf(file
, ";\n");
2014 print_file(file
, indent
, "}\n\n");
2020 void write_expr_eval_routine_list(FILE *file
, const char *iface
)
2022 struct expr_eval_routine
*eval
;
2023 struct expr_eval_routine
*cursor
;
2024 unsigned short callback_offset
= 0;
2026 fprintf(file
, "static const EXPR_EVAL ExprEvalRoutines[] =\n");
2027 fprintf(file
, "{\n");
2029 LIST_FOR_EACH_ENTRY_SAFE(eval
, cursor
, &expr_eval_routines
, struct expr_eval_routine
, entry
)
2031 print_file(file
, 1, "%s_%sExprEval_%04u,\n",
2032 iface
, eval
->structure
->name
, callback_offset
);
2035 list_remove(&eval
->entry
);
2039 fprintf(file
, "};\n\n");