?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
widl: Split pointer writing into a separate function.
[wine/wine64.git] / tools / widl / typegen.c
blob6bb2cae78ec9feeed78a1e6b70c4a5a3a3dcad77
1 /*
2 * Format String Generator for IDL Compiler
3 *
4 * Copyright 2005 Eric Kohl
5 * Copyright 2005-2006 Robert Shearman
6 *
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.
11 *
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.
16 *
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30 #include <string.h>
31 #include <assert.h>
32 #include <ctype.h>
33 #include <signal.h>
34 #include <limits.h>
35
36 #include "widl.h"
37 #include "utils.h"
38 #include "parser.h"
39 #include "header.h"
40 #include "windef.h"
41 #include "wine/list.h"
42
43 #include "widl.h"
44 #include "typegen.h"
45
46 static const func_t *current_func;
47 static const type_t *current_structure;
48
49 /* name of the structure variable for structure callbacks */
50 #define STRUCT_EXPR_EVAL_VAR "pS"
51
52 static struct list expr_eval_routines = LIST_INIT(expr_eval_routines);
53
54 struct expr_eval_routine
55 {
56 struct list entry;
57 const type_t *structure;
58 size_t structure_size;
59 const expr_t *expr;
60 };
61
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);
64
65 static int compare_expr(const expr_t *a, const expr_t *b)
66 {
67 int ret;
68
69 if (a->type != b->type)
70 return a->type - b->type;
71
72 switch (a->type)
73 {
74 case EXPR_NUM:
75 case EXPR_HEXNUM:
76 return a->u.lval - b->u.lval;
77 case EXPR_IDENTIFIER:
78 return strcmp(a->u.sval, b->u.sval);
79 case EXPR_COND:
80 ret = compare_expr(a->ref, b->ref);
81 if (ret != 0)
82 return ret;
83 ret = compare_expr(a->u.ext, b->u.ext);
84 if (ret != 0)
85 return ret;
86 return compare_expr(a->ext2, b->ext2);
87 case EXPR_OR:
88 case EXPR_AND:
89 case EXPR_ADD:
90 case EXPR_SUB:
91 case EXPR_MUL:
92 case EXPR_DIV:
93 case EXPR_SHL:
94 case EXPR_SHR:
95 ret = compare_expr(a->ref, b->ref);
96 if (ret != 0)
97 return ret;
98 return compare_expr(a->u.ext, b->u.ext);
99 case EXPR_NOT:
100 case EXPR_NEG:
101 case EXPR_PPTR:
102 case EXPR_CAST:
103 case EXPR_SIZEOF:
104 return compare_expr(a->ref, b->ref);
105 case EXPR_VOID:
106 return 0;
107 }
108 return -1;
109 }
110
111 #define WRITE_FCTYPE(file, fctype, typestring_offset) \
112 do { \
113 if (file) \
114 fprintf(file, "/* %2u */\n", typestring_offset); \
115 print_file((file), 2, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
116 } \
117 while (0)
118
119 static int print_file(FILE *file, int indent, const char *format, ...)
120 {
121 va_list va;
122 int i, r;
123
124 if (!file) return 0;
125
126 va_start(va, format);
127 for (i = 0; i < indent; i++)
128 fprintf(file, " ");
129 r = vfprintf(file, format, va);
130 va_end(va);
131 return r;
132 }
133
134 static inline int type_has_ref(const type_t *type)
135 {
136 return (type->type == 0 && type->ref);
137 }
138
139 static inline int is_base_type(unsigned char type)
140 {
141 switch (type)
142 {
143 case RPC_FC_BYTE:
144 case RPC_FC_CHAR:
145 case RPC_FC_USMALL:
146 case RPC_FC_SMALL:
147 case RPC_FC_WCHAR:
148 case RPC_FC_USHORT:
149 case RPC_FC_SHORT:
150 case RPC_FC_ULONG:
151 case RPC_FC_LONG:
152 case RPC_FC_HYPER:
153 case RPC_FC_IGNORE:
154 case RPC_FC_FLOAT:
155 case RPC_FC_DOUBLE:
156 case RPC_FC_ENUM16:
157 case RPC_FC_ENUM32:
158 case RPC_FC_ERROR_STATUS_T:
159 return TRUE;
160
161 default:
162 return FALSE;
163 }
164 }
165
166 static size_t write_procformatstring_var(FILE *file, int indent,
167 const var_t *var, int is_return, unsigned int *type_offset)
168 {
169 size_t size;
170 int ptr_level = var->ptr_level;
171 const type_t *type = var->type;
172
173 int is_in = is_attr(var->attrs, ATTR_IN);
174 int is_out = is_attr(var->attrs, ATTR_OUT);
175
176 if (!is_in && !is_out) is_in = TRUE;
177
178 if (ptr_level == 0 && type_has_ref(type))
179 type = type->ref;
180
181 if (ptr_level == 0 && !var->array && is_base_type(type->type))
182 {
183 if (is_return)
184 print_file(file, indent, "0x53, /* FC_RETURN_PARAM_BASETYPE */\n");
185 else
186 print_file(file, indent, "0x4e, /* FC_IN_PARAM_BASETYPE */\n");
187
188 switch(type->type)
189 {
190 #define CASE_BASETYPE(fctype) \
191 case RPC_##fctype: \
192 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
193 size = 2; /* includes param type prefix */ \
194 break
195
196 CASE_BASETYPE(FC_BYTE);
197 CASE_BASETYPE(FC_CHAR);
198 CASE_BASETYPE(FC_WCHAR);
199 CASE_BASETYPE(FC_USHORT);
200 CASE_BASETYPE(FC_SHORT);
201 CASE_BASETYPE(FC_ULONG);
202 CASE_BASETYPE(FC_LONG);
203 CASE_BASETYPE(FC_HYPER);
204 CASE_BASETYPE(FC_IGNORE);
205 CASE_BASETYPE(FC_USMALL);
206 CASE_BASETYPE(FC_SMALL);
207 CASE_BASETYPE(FC_FLOAT);
208 CASE_BASETYPE(FC_DOUBLE);
209 CASE_BASETYPE(FC_ERROR_STATUS_T);
210 #undef CASE_BASETYPE
211 default:
212 error("Unknown/unsupported type: %s (0x%02x)\n", var->name, type->type);
213 size = 0;
214 }
215 }
216 else
217 {
218 if (is_return)
219 print_file(file, indent, "0x52, /* FC_RETURN_PARAM */\n");
220 else if (is_in && is_out)
221 print_file(file, indent, "0x50, /* FC_IN_OUT_PARAM */\n");
222 else if (is_out)
223 print_file(file, indent, "0x51, /* FC_OUT_PARAM */\n");
224 else
225 print_file(file, indent, "0x4d, /* FC_IN_PARAM */\n");
226
227 print_file(file, indent, "0x01,\n");
228 print_file(file, indent, "NdrFcShort(0x%x),\n", *type_offset);
229 size = 4; /* includes param type prefix */
230 }
231 *type_offset += get_size_typeformatstring_var(var);
232 return size;
233 }
234
235 void write_procformatstring(FILE *file, type_t *iface)
236 {
237 int indent = 0;
238 var_t *var;
239 unsigned int type_offset = 2;
240
241 print_file(file, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
242 print_file(file, indent, "{\n");
243 indent++;
244 print_file(file, indent, "0,\n");
245 print_file(file, indent, "{\n");
246 indent++;
247
248 if (iface->funcs)
249 {
250 func_t *func = iface->funcs;
251 while (NEXT_LINK(func)) func = NEXT_LINK(func);
252 for (; func; func = PREV_LINK(func))
253 {
254 /* emit argument data */
255 if (func->args)
256 {
257 var = func->args;
258 while (NEXT_LINK(var)) var = NEXT_LINK(var);
259 while (var)
260 {
261 write_procformatstring_var(file, indent, var, FALSE,
262 &type_offset);
263
264 var = PREV_LINK(var);
265 }
266 }
267
268 /* emit return value data */
269 var = func->def;
270 if (is_void(var->type, NULL))
271 {
272 print_file(file, indent, "0x5b, /* FC_END */\n");
273 print_file(file, indent, "0x5c, /* FC_PAD */\n");
274 }
275 else
276 write_procformatstring_var(file, indent, var, TRUE,
277 &type_offset);
278 }
279 }
280
281 print_file(file, indent, "0x0\n");
282 indent--;
283 print_file(file, indent, "}\n");
284 indent--;
285 print_file(file, indent, "};\n");
286 print_file(file, indent, "\n");
287 }
288
289 /* write conformance / variance descriptor */
290 static size_t write_conf_or_var_desc(FILE *file, const func_t *func, const type_t *structure, const expr_t *expr)
291 {
292 unsigned char operator_type = 0;
293 const char *operator_string = "no operators";
294 const expr_t *subexpr = expr;
295 unsigned char correlation_type;
296
297 if (!file) return 4; /* optimisation for sizing pass */
298
299 if (expr->is_const)
300 {
301 if (expr->cval > UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX)
302 error("write_conf_or_var_desc: constant value %ld is greater than "
303 "the maximum constant size of %d\n", expr->cval,
304 UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX);
305
306 print_file(file, 2, "0x%x, /* Corr desc: constant, val = %ld */\n",
307 RPC_FC_CONSTANT_CONFORMANCE, expr->cval);
308 print_file(file, 2, "0x%x,\n", expr->cval & ~USHRT_MAX);
309 print_file(file, 2, "NdrShort(0x%x),\n", expr->cval & USHRT_MAX);
310
311 return 4;
312 }
313
314 switch (subexpr->type)
315 {
316 case EXPR_PPTR:
317 subexpr = subexpr->ref;
318 operator_type = RPC_FC_DEREFERENCE;
319 operator_string = "FC_DEREFERENCE";
320 break;
321 case EXPR_DIV:
322 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
323 {
324 subexpr = subexpr->ref;
325 operator_type = RPC_FC_DIV_2;
326 operator_string = "FC_DIV_2";
327 }
328 break;
329 case EXPR_MUL:
330 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
331 {
332 subexpr = subexpr->ref;
333 operator_type = RPC_FC_MULT_2;
334 operator_string = "FC_MULT_2";
335 }
336 break;
337 case EXPR_SUB:
338 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
339 {
340 subexpr = subexpr->ref;
341 operator_type = RPC_FC_SUB_1;
342 operator_string = "FC_SUB_1";
343 }
344 break;
345 case EXPR_ADD:
346 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
347 {
348 subexpr = subexpr->ref;
349 operator_type = RPC_FC_ADD_1;
350 operator_string = "FC_ADD_1";
351 }
352 break;
353 default:
354 break;
355 }
356
357 if (subexpr->type == EXPR_IDENTIFIER)
358 {
359 const type_t *correlation_variable = NULL;
360 unsigned char param_type = 0;
361 const char *param_type_string = NULL;
362 size_t offset;
363
364 if (structure)
365 {
366 const var_t *var;
367
368 for (offset = 0, var = structure->fields; var; var = NEXT_LINK(var))
369 {
370 offset -= type_memsize(var->type, var->ptr_level, var->array);
371 if (!strcmp(var->name, subexpr->u.sval))
372 {
373 correlation_variable = var->type;
374 break;
375 }
376 }
377 if (!correlation_variable)
378 error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
379 subexpr->u.sval);
380
381 correlation_type = RPC_FC_NORMAL_CONFORMANCE;
382 }
383 else
384 {
385 const var_t *var = func->args;
386
387 while (NEXT_LINK(var)) var = NEXT_LINK(var);
388 /* FIXME: not all stack variables are sizeof(void *) */
389 for (offset = 0; var; offset += sizeof(void *), var = PREV_LINK(var))
390 {
391 if (!strcmp(var->name, subexpr->u.sval))
392 {
393 correlation_variable = var->type;
394 break;
395 }
396 }
397 if (!correlation_variable)
398 error("write_conf_or_var_desc: couldn't find variable %s in function\n",
399 subexpr->u.sval);
400
401 correlation_type = RPC_FC_TOP_LEVEL_CONFORMANCE;
402 }
403
404 while (type_has_ref(correlation_variable))
405 correlation_variable = correlation_variable->ref;
406
407 switch (correlation_variable->type)
408 {
409 case RPC_FC_CHAR:
410 case RPC_FC_SMALL:
411 param_type = RPC_FC_SMALL;
412 param_type_string = "FC_SMALL";
413 break;
414 case RPC_FC_BYTE:
415 case RPC_FC_USMALL:
416 param_type = RPC_FC_USMALL;
417 param_type_string = "FC_USMALL";
418 break;
419 case RPC_FC_WCHAR:
420 case RPC_FC_SHORT:
421 param_type = RPC_FC_SHORT;
422 param_type_string = "FC_SHORT";
423 break;
424 case RPC_FC_USHORT:
425 param_type = RPC_FC_USHORT;
426 param_type_string = "FC_USHORT";
427 break;
428 case RPC_FC_LONG:
429 param_type = RPC_FC_LONG;
430 param_type_string = "FC_LONG";
431 break;
432 case RPC_FC_ULONG:
433 param_type = RPC_FC_ULONG;
434 param_type_string = "FC_ULONG";
435 break;
436 default:
437 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n",
438 correlation_variable->type);
439 }
440
441 print_file(file, 2, "0x%x, /* Corr desc: %s%s */\n",
442 correlation_type | param_type,
443 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "parameter, " : "",
444 param_type_string);
445 print_file(file, 2, "0x%x, /* %s */\n", operator_type, operator_string);
446 print_file(file, 2, "NdrShort(0x%x), /* %soffset = %d */\n",
447 offset,
448 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "x86 stack size / " : "",
449 offset);
450 }
451 else
452 {
453 unsigned int callback_offset = 0;
454
455 if (structure)
456 {
457 struct expr_eval_routine *eval;
458 int found = 0;
459
460 LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
461 {
462 if (!strcmp(eval->structure->name, structure->name) &&
463 !compare_expr(eval->expr, expr))
464 {
465 found = 1;
466 break;
467 }
468 callback_offset++;
469 }
470
471 if (!found)
472 {
473 eval = xmalloc(sizeof(*eval));
474 eval->structure = structure;
475 eval->structure_size = fields_memsize(structure->fields);
476 eval->expr = expr;
477 list_add_tail(&expr_eval_routines, &eval->entry);
478 }
479
480 correlation_type = RPC_FC_NORMAL_CONFORMANCE;
481 }
482 else
483 {
484 error("write_conf_or_var_desc: top-level callback conformance unimplemented\n");
485 correlation_type = RPC_FC_TOP_LEVEL_CONFORMANCE;
486 }
487
488 if (callback_offset > USHRT_MAX)
489 error("Maximum number of callback routines reached\n");
490
491 print_file(file, 2, "0x%x, /* Corr desc: %s */\n",
492 correlation_type,
493 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "parameter" : "");
494 print_file(file, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK");
495 print_file(file, 2, "NdrShort(0x%x), /* %u */\n", callback_offset, callback_offset);
496 }
497 return 4;
498 }
499
500 static size_t fields_memsize(const var_t *v)
501 {
502 size_t size = 0;
503 const var_t *first = v;
504 if (!v) return 0;
505 while (NEXT_LINK(v)) v = NEXT_LINK(v);
506 while (v) {
507 size += type_memsize(v->type, v->ptr_level, v->array);
508 if (v == first) break;
509 v = PREV_LINK(v);
510 }
511 return size;
512 }
513
514 static size_t type_memsize(const type_t *t, int ptr_level, const expr_t *array)
515 {
516 size_t size = 0;
517
518 if (ptr_level)
519 return sizeof(void *);
520
521 switch (t->type)
522 {
523 case RPC_FC_BYTE:
524 case RPC_FC_CHAR:
525 case RPC_FC_USMALL:
526 case RPC_FC_SMALL:
527 size = 1;
528 break;
529 case RPC_FC_WCHAR:
530 case RPC_FC_USHORT:
531 case RPC_FC_SHORT:
532 case RPC_FC_ENUM16:
533 size = 2;
534 break;
535 case RPC_FC_ULONG:
536 case RPC_FC_LONG:
537 case RPC_FC_ERROR_STATUS_T:
538 case RPC_FC_ENUM32:
539 case RPC_FC_FLOAT:
540 size = 4;
541 break;
542 case RPC_FC_HYPER:
543 case RPC_FC_DOUBLE:
544 size = 8;
545 break;
546 case RPC_FC_STRUCT:
547 case RPC_FC_CVSTRUCT:
548 case RPC_FC_CPSTRUCT:
549 case RPC_FC_CSTRUCT:
550 case RPC_FC_PSTRUCT:
551 case RPC_FC_BOGUS_STRUCT:
552 case RPC_FC_ENCAPSULATED_UNION:
553 case RPC_FC_NON_ENCAPSULATED_UNION:
554 size = fields_memsize(t->fields);
555 break;
556 default:
557 error("type_memsize: Unknown type %d", t->type);
558 size = 0;
559 }
560
561 if (array)
562 {
563 if (array->is_const)
564 size *= array->cval;
565 else
566 size = 0;
567 }
568
569 return size;
570 }
571
572 static int write_pointers(FILE *file, const attr_t *attrs,
573 const type_t *type, int ptr_level,
574 const expr_t *array, int level,
575 size_t *typestring_offset)
576 {
577 int pointers_written = 0;
578 const var_t *v;
579
580 /* don't generate a pointer for first-level arrays since we want to
581 * descend into them to write their pointers, not stop here */
582 if ((level == 0 || ptr_level == 0) && is_array_type(attrs, ptr_level, array))
583 {
584 return write_pointers(file, NULL, type, 0, NULL, level + 1, typestring_offset);
585 }
586
587 if (ptr_level != 0)
588 {
589 /* FIXME: only general algorithm implemented, not the actual writing */
590 error("write_pointers: Writing type format string for pointer is unimplemented\n");
591 return 1;
592 }
593
594 /* FIXME: search through all refs for pointers too */
595 while(type_has_ref(type))
596 type = type->ref;
597
598 switch (type->type)
599 {
600 /* note: don't descend into complex structures or unions since these
601 * will always be generated as a separate type */
602 case RPC_FC_STRUCT:
603 case RPC_FC_CVSTRUCT:
604 case RPC_FC_CPSTRUCT:
605 case RPC_FC_CSTRUCT:
606 case RPC_FC_PSTRUCT:
607 v = type->fields;
608 if (!v) break;
609 while (NEXT_LINK(v)) v = NEXT_LINK(v);
610 for (; v; v = PREV_LINK(v))
611 pointers_written += write_pointers(file, v->attrs, v->type,
612 v->ptr_level, v->array,
613 level + 1,
614 typestring_offset);
615
616 break;
617
618 default:
619 /* nothing to do */
620 break;
621 }
622
623 return pointers_written;
624 }
625
626 static size_t write_pointer_description(FILE *file, const attr_t *attrs,
627 const type_t *type, int ptr_level,
628 const expr_t *array, int level,
629 size_t typestring_offset)
630 {
631 size_t size = 0;
632 const var_t *v;
633
634 /* don't generate a pointer for first-level arrays since we want to
635 * descend into them to write their pointers, not stop here */
636 if ((level == 0 || ptr_level == 0) && is_array_type(attrs, ptr_level, array))
637 {
638 return write_pointer_description(file, NULL, type, 0, NULL,
639 level + 1, typestring_offset);
640 }
641
642 if (ptr_level != 0)
643 {
644 /* FIXME: only general algorithm implemented, not the actual writing */
645 error("write_pointer_description: Writing pointer description is unimplemented\n");
646 return 0;
647 }
648
649 /* FIXME: search through all refs for pointers too */
650
651 switch (type->type)
652 {
653 /* note: don't descend into complex structures or unions since these
654 * will always be generated as a separate type */
655 case RPC_FC_STRUCT:
656 case RPC_FC_CVSTRUCT:
657 case RPC_FC_CPSTRUCT:
658 case RPC_FC_CSTRUCT:
659 case RPC_FC_PSTRUCT:
660 v = type->fields;
661 if (!v) break;
662 while (NEXT_LINK(v)) v = NEXT_LINK(v);
663 for (; v; v = PREV_LINK(v))
664 size += write_pointer_description(file, v->attrs, v->type,
665 v->ptr_level, v->array,
666 level + 1,
667 typestring_offset);
668
669 break;
670
671 default:
672 /* nothing to do */
673 break;
674 }
675
676 return size;
677 }
678
679 static size_t write_string_tfs(FILE *file, const attr_t *attrs,
680 const type_t *type, const expr_t *array,
681 const char *name, size_t *typestring_offset)
682 {
683 const expr_t *size_is = get_attrp(attrs, ATTR_SIZEIS);
684 int has_size = size_is && (size_is->type != EXPR_VOID);
685 size_t start_offset = *typestring_offset;
686
687 if ((type->type != RPC_FC_BYTE) && (type->type != RPC_FC_CHAR) && (type->type != RPC_FC_WCHAR))
688 {
689 error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", type->type, name);
690 return start_offset;
691 }
692
693 if (array && array->is_const)
694 {
695 if (array->cval > USHRT_MAX)
696 error("array size for parameter %s exceeds %d bytes by %ld bytes\n",
697 name, USHRT_MAX, array->cval - USHRT_MAX);
698
699 if (type->type == RPC_FC_CHAR)
700 WRITE_FCTYPE(file, FC_CSTRING, *typestring_offset);
701 else
702 WRITE_FCTYPE(file, FC_WSTRING, *typestring_offset);
703 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
704 *typestring_offset += 2;
705
706 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", array->cval, array->cval);
707 *typestring_offset += 2;
708
709 return start_offset;
710 }
711 else if (has_size)
712 {
713 if (type->type == RPC_FC_CHAR)
714 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
715 else
716 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
717 print_file(file, 2, "0x%x, /* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED);
718 *typestring_offset += 2;
719
720 *typestring_offset += write_conf_or_var_desc(file, current_func, NULL, size_is);
721
722 return start_offset;
723 }
724 else
725 {
726 if (type->type == RPC_FC_CHAR)
727 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
728 else
729 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
730 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
731 *typestring_offset += 2;
732
733 return start_offset;
734 }
735 }
736
737 static size_t write_array_tfs(FILE *file, const attr_t *attrs,
738 const type_t *type, const expr_t *array,
739 const char *name, size_t *typestring_offset)
740 {
741 const expr_t *length_is = get_attrp(attrs, ATTR_LENGTHIS);
742 const expr_t *size_is = get_attrp(attrs, ATTR_SIZEIS);
743 int has_length = length_is && (length_is->type != EXPR_VOID);
744 int has_size = (size_is && (size_is->type != EXPR_VOID)) || !array->is_const;
745 size_t start_offset;
746
747 if (array && NEXT_LINK(array)) /* multi-dimensional array */
748 {
749 error("write_array_tfs: Multi-dimensional arrays not implemented yet (param %s)\n", name);
750 return 0;
751 }
752 else
753 {
754 size_t pointer_start_offset = *typestring_offset;
755 int has_pointer = 0;
756
757 if (write_pointers(file, attrs, type, 0, array, 0, typestring_offset) > 0)
758 has_pointer = 1;
759
760 start_offset = *typestring_offset;
761
762 if (!has_length && !has_size)
763 {
764 /* fixed array */
765 size_t size = type_memsize(type, 0, array);
766 if (size < USHRT_MAX)
767 {
768 WRITE_FCTYPE(file, FC_SMFARRAY, *typestring_offset);
769 /* alignment */
770 print_file(file, 2, "0x%x, /* 0 */\n", 0);
771 /* size */
772 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", size, size);
773 *typestring_offset += 4;
774 }
775 else
776 {
777 WRITE_FCTYPE(file, FC_LGFARRAY, *typestring_offset);
778 /* alignment */
779 print_file(file, 2, "0x%x, /* 0 */\n", 0);
780 /* size */
781 print_file(file, 2, "NdrFcLong(0x%x), /* %d */\n", size, size);
782 *typestring_offset += 6;
783 }
784
785 if (has_pointer)
786 {
787 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
788 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
789 *typestring_offset += 2;
790 *typestring_offset = write_pointer_description(file, attrs,
791 type, 0, array, 0, pointer_start_offset);
792 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
793 *typestring_offset += 1;
794 }
795
796 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
797 print_file(file, 2, "FC_END,\n");
798 *typestring_offset += 2;
799
800 return start_offset;
801 }
802 else if (has_length && !has_size)
803 {
804 /* varying array */
805 size_t element_size = type_memsize(type, 0, NULL);
806 size_t elements = array->cval;
807 size_t total_size = element_size * elements;
808
809 if (total_size < USHRT_MAX)
810 {
811 WRITE_FCTYPE(file, FC_SMVARRAY, *typestring_offset);
812 /* alignment */
813 print_file(file, 2, "0x%x, /* 0 */\n", 0);
814 /* total size */
815 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", total_size, total_size);
816 /* number of elements */
817 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", elements, elements);
818 *typestring_offset += 6;
819 }
820 else
821 {
822 WRITE_FCTYPE(file, FC_LGVARRAY, *typestring_offset);
823 /* alignment */
824 print_file(file, 2, "0x%x, /* 0 */\n", 0);
825 /* total size */
826 print_file(file, 2, "NdrFcLong(0x%x), /* %d */\n", total_size, total_size);
827 /* number of elements */
828 print_file(file, 2, "NdrFcLong(0x%x), /* %d */\n", elements, elements);
829 *typestring_offset += 10;
830 }
831 /* element size */
832 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", element_size, element_size);
833 *typestring_offset += 2;
834
835 *typestring_offset += write_conf_or_var_desc(file, current_func,
836 current_structure,
837 length_is);
838
839 if (has_pointer)
840 {
841 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
842 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
843 *typestring_offset += 2;
844 *typestring_offset += write_pointer_description(file, attrs,
845 type, 0, array, 0, pointer_start_offset);
846 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
847 *typestring_offset += 1;
848 }
849
850 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
851 print_file(file, 2, "FC_END,\n");
852 *typestring_offset += 2;
853
854 return start_offset;
855 }
856 else if (!has_length && has_size)
857 {
858 /* conformant array */
859 size_t element_size = type_memsize(type, 0, NULL);
860
861 WRITE_FCTYPE(file, FC_CARRAY, *typestring_offset);
862 /* alignment */
863 print_file(file, 2, "0x%x, /* 0 */\n", 0);
864 /* element size */
865 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", element_size, element_size);
866 *typestring_offset += 4;
867
868 *typestring_offset += write_conf_or_var_desc(file, current_func,
869 current_structure,
870 size_is ? size_is : array);
871
872 if (has_pointer)
873 {
874 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
875 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
876 *typestring_offset += 2;
877 *typestring_offset += write_pointer_description(file, attrs,
878 type, 0, array, 0, pointer_start_offset);
879 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
880 *typestring_offset += 1;
881 }
882
883 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
884 print_file(file, 2, "FC_END,\n");
885 *typestring_offset += 2;
886
887 return start_offset;
888 }
889 else
890 {
891 /* conformant varying array */
892 size_t element_size = type_memsize(type, 0, NULL);
893
894 WRITE_FCTYPE(file, FC_CVARRAY, *typestring_offset);
895 /* alignment */
896 print_file(file, 2, "0x%x, /* 0 */\n", 0);
897 /* element size */
898 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", element_size, element_size);
899 *typestring_offset += 4;
900
901 *typestring_offset += write_conf_or_var_desc(file, current_func,
902 current_structure,
903 size_is ? size_is : array);
904 *typestring_offset += write_conf_or_var_desc(file, current_func,
905 current_structure,
906 length_is);
907
908 if (has_pointer)
909 {
910 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
911 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
912 *typestring_offset += 2;
913 *typestring_offset += write_pointer_description(file, attrs,
914 type, 0, array, 0, pointer_start_offset);
915 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
916 *typestring_offset += 1;
917 }
918
919 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
920 print_file(file, 2, "FC_END,\n");
921 *typestring_offset += 2;
922
923 return start_offset;
924 }
925 }
926 }
927
928 static const var_t *find_array_or_string_in_struct(const type_t *type)
929 {
930 /* last field is the first in the fields linked list */
931 const var_t *last_field = type->fields;
932 if (is_array_type(last_field->attrs, last_field->ptr_level, last_field->array))
933 return last_field;
934
935 assert((last_field->type->type == RPC_FC_CSTRUCT) ||
936 (last_field->type->type == RPC_FC_CPSTRUCT) ||
937 (last_field->type->type == RPC_FC_CVSTRUCT));
938
939 return find_array_or_string_in_struct(last_field->type);
940 }
941
942 static size_t write_struct_tfs(FILE *file, const type_t *type,
943 const char *name, size_t *typestring_offset)
944 {
945 size_t total_size;
946 const var_t *array;
947 size_t start_offset;
948 size_t array_offset;
949 size_t pointer_offset;
950
951 switch (type->type)
952 {
953 case RPC_FC_STRUCT:
954 case RPC_FC_PSTRUCT:
955 total_size = type_memsize(type, 0, NULL);
956
957 if (total_size > USHRT_MAX)
958 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
959 name, USHRT_MAX, total_size - USHRT_MAX);
960
961 if (type->type == RPC_FC_PSTRUCT)
962 {
963 pointer_offset = *typestring_offset;
964 write_pointers(file, NULL, type, 0, NULL, 0, typestring_offset);
965 }
966 else pointer_offset = 0; /* silence warning */
967
968 start_offset = *typestring_offset;
969 WRITE_FCTYPE(file, FC_STRUCT, *typestring_offset);
970 /* alignment */
971 print_file(file, 2, "0x0,\n");
972 /* total size */
973 print_file(file, 2, "NdrShort(0x%x), /* %u */\n", total_size, total_size);
974 *typestring_offset += 4;
975
976 if (type->type == RPC_FC_PSTRUCT)
977 {
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, NULL,
982 type, 0, NULL, 0, pointer_offset);
983 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
984 *typestring_offset += 1;
985 }
986
987 /* member layout */
988 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
989 print_file(file, 2, "FC_END,\n");
990
991 *typestring_offset += 2;
992 return start_offset;
993 case RPC_FC_CSTRUCT:
994 case RPC_FC_CPSTRUCT:
995 total_size = type_memsize(type, 0, NULL);
996
997 if (total_size > USHRT_MAX)
998 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
999 name, USHRT_MAX, total_size - USHRT_MAX);
1000
1001 array = find_array_or_string_in_struct(type);
1002 current_structure = type;
1003 array_offset = write_array_tfs(file, array->attrs, array->type,
1004 array->array, array->name,
1005 typestring_offset);
1006 current_structure = NULL;
1007
1008 if (type->type == RPC_FC_CPSTRUCT)
1009 {
1010 pointer_offset = *typestring_offset;
1011 write_pointers(file, NULL, type, 0, NULL, 0, typestring_offset);
1012 }
1013 else pointer_offset = 0; /* silence warning */
1014
1015 start_offset = *typestring_offset;
1016 WRITE_FCTYPE(file, FC_CSTRUCT, *typestring_offset);
1017 /* alignment */
1018 print_file(file, 2, "0x0,\n");
1019 /* total size */
1020 print_file(file, 2, "NdrShort(0x%x), /* %u */\n", total_size, total_size);
1021 *typestring_offset += 4;
1022 print_file(file, 2, "NdrShort(0x%x), /* offset = %d (%u) */\n",
1023 array_offset - *typestring_offset,
1024 array_offset - *typestring_offset,
1025 array_offset);
1026 *typestring_offset += 2;
1027
1028 if (type->type == RPC_FC_CPSTRUCT)
1029 {
1030 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1031 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1032 *typestring_offset += 2;
1033 *typestring_offset += write_pointer_description(file, NULL,
1034 type, 0, NULL, 0, pointer_offset);
1035 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1036 *typestring_offset += 1;
1037 }
1038
1039 print_file(file, 2, "FC_END,\n");
1040 *typestring_offset += 1;
1041
1042 return start_offset;
1043 case RPC_FC_CVSTRUCT:
1044 total_size = type_memsize(type, 0, NULL);
1045
1046 if (total_size > USHRT_MAX)
1047 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1048 name, USHRT_MAX, total_size - USHRT_MAX);
1049
1050 array = find_array_or_string_in_struct(type);
1051 current_structure = type;
1052 if (is_attr(array->attrs, ATTR_STRING))
1053 array_offset = write_string_tfs(file, array->attrs, array->type,
1054 array->array, array->name,
1055 typestring_offset);
1056 else
1057 array_offset = write_array_tfs(file, array->attrs, array->type,
1058 array->array, array->name,
1059 typestring_offset);
1060 current_structure = NULL;
1061
1062 pointer_offset = *typestring_offset;
1063 if (!write_pointers(file, NULL, type, 0, NULL, 0, typestring_offset))
1064 pointer_offset = 0;
1065
1066 start_offset = *typestring_offset;
1067 WRITE_FCTYPE(file, FC_CVSTRUCT, *typestring_offset);
1068 /* alignment */
1069 print_file(file, 2, "0x0,\n");
1070 /* total size */
1071 print_file(file, 2, "NdrShort(0x%x), /* %u */\n", total_size, total_size);
1072 *typestring_offset += 4;
1073 print_file(file, 2, "NdrShort(0x%x), /* offset = %d (%u) */\n",
1074 array_offset - *typestring_offset,
1075 array_offset - *typestring_offset,
1076 array_offset);
1077 *typestring_offset += 2;
1078
1079 if (pointer_offset != 0)
1080 {
1081 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1082 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1083 *typestring_offset += 2;
1084 *typestring_offset += write_pointer_description(file, NULL,
1085 type, 0, NULL, 0, pointer_offset);
1086 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1087 *typestring_offset += 1;
1088 }
1089
1090 print_file(file, 2, "FC_END,\n");
1091 *typestring_offset += 1;
1092
1093 return start_offset;
1094 default:
1095 error("write_struct_tfs: Unimplemented for type 0x%x\n", type->type);
1096 return *typestring_offset;
1097 }
1098 }
1099
1100 static void write_pointer_only_tfs(FILE *file, const attr_t *attrs, size_t offset, size_t *typeformat_offset)
1101 {
1102 int pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
1103 if (!pointer_type) pointer_type = RPC_FC_RP;
1104
1105 print_file(file, 2, "0x%x, 0x00, /* %s */\n",
1106 pointer_type,
1107 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"));
1108 print_file(file, 2, "NdrShort(0x%x), /* %d */\n", offset, offset);
1109 *typeformat_offset += 4;
1110 }
1111
1112 static size_t write_union_tfs(FILE *file, const attr_t *attrs,
1113 const type_t *type, const char *name,
1114 size_t *typeformat_offset)
1115 {
1116 error("write_union_tfs: Unimplemented\n");
1117 return *typeformat_offset;
1118 }
1119
1120 static size_t write_typeformatstring_var(FILE *file, int indent,
1121 const var_t *var, size_t *typeformat_offset)
1122 {
1123 const type_t *type = var->type;
1124 int ptr_level = var->ptr_level;
1125
1126 while (TRUE)
1127 {
1128 if (is_string_type(var->attrs, ptr_level, var->array))
1129 return write_string_tfs(file, var->attrs, type, var->array, var->name, typeformat_offset);
1130
1131 if (is_array_type(var->attrs, ptr_level, var->array))
1132 return write_array_tfs(file, var->attrs, type, var->array, var->name, typeformat_offset);
1133
1134 if (ptr_level == 0)
1135 {
1136 /* follow reference if the type has one */
1137 if (type_has_ref(type))
1138 {
1139 type = type->ref;
1140 /* FIXME: get new ptr_level from type */
1141 continue;
1142 }
1143
1144 /* basic types don't need a type format string */
1145 if (is_base_type(type->type))
1146 return 0;
1147
1148 switch (type->type)
1149 {
1150 case RPC_FC_STRUCT:
1151 case RPC_FC_PSTRUCT:
1152 case RPC_FC_CSTRUCT:
1153 case RPC_FC_CPSTRUCT:
1154 case RPC_FC_CVSTRUCT:
1155 case RPC_FC_BOGUS_STRUCT:
1156 return write_struct_tfs(file, type, var->name, typeformat_offset);
1157 case RPC_FC_ENCAPSULATED_UNION:
1158 case RPC_FC_NON_ENCAPSULATED_UNION:
1159 return write_union_tfs(file, var->attrs, type, var->name, typeformat_offset);
1160 case RPC_FC_IGNORE:
1161 case RPC_FC_BIND_PRIMITIVE:
1162 /* nothing to do */
1163 return 0;
1164 default:
1165 error("write_typeformatstring_var: Unsupported type 0x%x for variable %s\n", type->type, var->name);
1166 }
1167 }
1168 else if (ptr_level == 1 && !type_has_ref(type))
1169 {
1170 size_t start_offset = *typeformat_offset;
1171 int pointer_type = get_attrv(var->attrs, ATTR_POINTERTYPE);
1172 if (!pointer_type) pointer_type = RPC_FC_RP;
1173
1174 /* special case for pointers to base types */
1175 switch (type->type)
1176 {
1177 #define CASE_BASETYPE(fctype) \
1178 case RPC_##fctype: \
1179 print_file(file, indent, "0x%x, 0x08, /* %s [simple_pointer] */\n", \
1180 pointer_type, \
1181 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP")); \
1182 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
1183 print_file(file, indent, "0x5c, /* FC_PAD */\n"); \
1184 *typeformat_offset += 4; \
1185 return start_offset
1186 CASE_BASETYPE(FC_BYTE);
1187 CASE_BASETYPE(FC_CHAR);
1188 CASE_BASETYPE(FC_SMALL);
1189 CASE_BASETYPE(FC_USMALL);
1190 CASE_BASETYPE(FC_WCHAR);
1191 CASE_BASETYPE(FC_SHORT);
1192 CASE_BASETYPE(FC_USHORT);
1193 CASE_BASETYPE(FC_LONG);
1194 CASE_BASETYPE(FC_ULONG);
1195 CASE_BASETYPE(FC_FLOAT);
1196 CASE_BASETYPE(FC_HYPER);
1197 CASE_BASETYPE(FC_DOUBLE);
1198 CASE_BASETYPE(FC_ENUM16);
1199 CASE_BASETYPE(FC_ENUM32);
1200 CASE_BASETYPE(FC_IGNORE);
1201 CASE_BASETYPE(FC_ERROR_STATUS_T);
1202 default:
1203 break;
1204 }
1205 }
1206
1207 assert(ptr_level > 0);
1208
1209 if (file)
1210 fprintf(file, "/* %2u */\n", *typeformat_offset);
1211 write_pointer_only_tfs(file, var->attrs, 2, typeformat_offset);
1212
1213 ptr_level--;
1214 }
1215 }
1216
1217
1218 void write_typeformatstring(FILE *file, type_t *iface)
1219 {
1220 int indent = 0;
1221 var_t *var;
1222 size_t typeformat_offset;
1223
1224 print_file(file, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
1225 print_file(file, indent, "{\n");
1226 indent++;
1227 print_file(file, indent, "0,\n");
1228 print_file(file, indent, "{\n");
1229 indent++;
1230 print_file(file, indent, "NdrFcShort(0x0),\n");
1231 typeformat_offset = 2;
1232
1233 if (iface->funcs)
1234 {
1235 func_t *func = iface->funcs;
1236 while (NEXT_LINK(func)) func = NEXT_LINK(func);
1237 for (; func; func = PREV_LINK(func))
1238 {
1239 current_func = func;
1240 if (func->args)
1241 {
1242 var = func->args;
1243 while (NEXT_LINK(var)) var = NEXT_LINK(var);
1244 while (var)
1245 {
1246 write_typeformatstring_var(file, indent, var,
1247 &typeformat_offset);
1248 var = PREV_LINK(var);
1249 }
1250 }
1251 }
1252 }
1253
1254 print_file(file, indent, "0x0\n");
1255 indent--;
1256 print_file(file, indent, "}\n");
1257 indent--;
1258 print_file(file, indent, "};\n");
1259 print_file(file, indent, "\n");
1260 }
1261
1262 static unsigned int get_required_buffer_size_type(
1263 const type_t *type, int ptr_level, const expr_t *array,
1264 const char *name, unsigned int *alignment)
1265 {
1266 *alignment = 0;
1267 if (ptr_level == 0 && !array && !type_has_ref(type))
1268 {
1269 switch (type->type)
1270 {
1271 case RPC_FC_BYTE:
1272 case RPC_FC_CHAR:
1273 case RPC_FC_USMALL:
1274 case RPC_FC_SMALL:
1275 return 1;
1276
1277 case RPC_FC_WCHAR:
1278 case RPC_FC_USHORT:
1279 case RPC_FC_SHORT:
1280 *alignment = 2;
1281 return 2;
1282
1283 case RPC_FC_ULONG:
1284 case RPC_FC_LONG:
1285 case RPC_FC_FLOAT:
1286 case RPC_FC_ERROR_STATUS_T:
1287 *alignment = 4;
1288 return 4;
1289
1290 case RPC_FC_HYPER:
1291 case RPC_FC_DOUBLE:
1292 *alignment = 8;
1293 return 8;
1294
1295 case RPC_FC_IGNORE:
1296 case RPC_FC_BIND_PRIMITIVE:
1297 return 0;
1298
1299 case RPC_FC_STRUCT:
1300 {
1301 size_t size = 0;
1302 const var_t *field;
1303 for (field = type->fields; field; field = NEXT_LINK(field))
1304 {
1305 unsigned int alignment;
1306 size += get_required_buffer_size_type(
1307 field->type, field->ptr_level, field->array, field->name,
1308 &alignment);
1309 }
1310 return size;
1311 }
1312
1313 default:
1314 error("get_required_buffer_size: Unknown/unsupported type: %s (0x%02x)\n", name, type->type);
1315 return 0;
1316 }
1317 }
1318 if (ptr_level == 0 && type_has_ref(type))
1319 return get_required_buffer_size_type(type->ref, 0 /* FIXME */, array, name, alignment);
1320 return 0;
1321 }
1322
1323 unsigned int get_required_buffer_size(const var_t *var, unsigned int *alignment)
1324 {
1325 return get_required_buffer_size_type(var->type, var->ptr_level, var->array, var->name, alignment);
1326 }
1327
1328 void marshall_arguments(FILE *file, int indent, func_t *func,
1329 unsigned int *type_offset, enum pass pass)
1330 {
1331 unsigned int last_size = 0;
1332 var_t *var;
1333
1334 if (!func->args)
1335 return;
1336
1337 var = func->args;
1338 while (NEXT_LINK(var)) var = NEXT_LINK(var);
1339 for (; var; *type_offset += get_size_typeformatstring_var(var), var = PREV_LINK(var))
1340 {
1341 int in_attr = is_attr(var->attrs, ATTR_IN);
1342 int out_attr = is_attr(var->attrs, ATTR_OUT);
1343
1344 if (!in_attr && !out_attr)
1345 in_attr = 1;
1346
1347 switch (pass)
1348 {
1349 case PASS_IN:
1350 if (!in_attr)
1351 continue;
1352 break;
1353 case PASS_OUT:
1354 if (!out_attr)
1355 continue;
1356 break;
1357 case PASS_RETURN:
1358 break;
1359 }
1360
1361 if (is_string_type(var->attrs, var->ptr_level, var->array))
1362 {
1363 if (var->array && var->array->is_const)
1364 print_file(file, indent,
1365 "NdrNonConformantStringMarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d]);\n",
1366 var->name, *type_offset);
1367 else
1368 print_file(file, indent,
1369 "NdrConformantStringMarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d]);\n",
1370 var->name, *type_offset);
1371 last_size = 1;
1372 }
1373 else if (is_array_type(var->attrs, var->ptr_level, var->array))
1374 {
1375 const expr_t *length_is = get_attrp(var->attrs, ATTR_LENGTHIS);
1376 const expr_t *size_is = get_attrp(var->attrs, ATTR_SIZEIS);
1377 const char *array_type;
1378 int has_length = length_is && (length_is->type != EXPR_VOID);
1379 int has_size = (size_is && (size_is->type != EXPR_VOID)) || !var->array->is_const;
1380
1381 if (var->array && NEXT_LINK(var->array)) /* multi-dimensional array */
1382 array_type = "ComplexArray";
1383 else
1384 {
1385 if (!has_length && !has_size)
1386 array_type = "FixedArray";
1387 else if (has_length && !has_size)
1388 {
1389 print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1390 print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
1391 write_expr(file, length_is, 1);
1392 fprintf(file, ";\n\n");
1393 array_type = "VaryingArray";
1394 }
1395 else if (!has_length && has_size)
1396 {
1397 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
1398 write_expr(file, size_is ? size_is : var->array, 1);
1399 fprintf(file, ";\n\n");
1400 array_type = "ConformantArray";
1401 }
1402 else
1403 {
1404 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
1405 write_expr(file, size_is ? size_is : var->array, 1);
1406 fprintf(file, ";\n");
1407 print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1408 print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
1409 write_expr(file, length_is, 1);
1410 fprintf(file, ";\n\n");
1411 array_type = "ConformantVaryingArray";
1412 }
1413 }
1414
1415 print_file(file, indent,
1416 "Ndr%sMarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d]);\n",
1417 array_type, var->name, *type_offset);
1418 last_size = 1;
1419 }
1420 else if (var->ptr_level == 0 && is_base_type(var->type->type))
1421 {
1422 unsigned int size;
1423 unsigned int alignment = 0;
1424 switch (var->type->type)
1425 {
1426 case RPC_FC_BYTE:
1427 case RPC_FC_CHAR:
1428 case RPC_FC_SMALL:
1429 case RPC_FC_USMALL:
1430 size = 1;
1431 alignment = 0;
1432 break;
1433
1434 case RPC_FC_WCHAR:
1435 case RPC_FC_USHORT:
1436 case RPC_FC_SHORT:
1437 size = 2;
1438 if (last_size != 0 && last_size < 2)
1439 alignment = (2 - last_size);
1440 break;
1441
1442 case RPC_FC_ULONG:
1443 case RPC_FC_LONG:
1444 case RPC_FC_FLOAT:
1445 case RPC_FC_ERROR_STATUS_T:
1446 size = 4;
1447 if (last_size != 0 && last_size < 4)
1448 alignment = (4 - last_size);
1449 break;
1450
1451 case RPC_FC_HYPER:
1452 case RPC_FC_DOUBLE:
1453 size = 8;
1454 if (last_size != 0 && last_size < 4)
1455 alignment = (4 - last_size);
1456 break;
1457
1458 default:
1459 error("marshall_arguments: Unsupported type: %s (0x%02x, ptr_level: 0)\n", var->name, var->type->type);
1460 size = 0;
1461 }
1462
1463 if (alignment != 0)
1464 print_file(file, indent, "_StubMsg.Buffer += %u;\n", alignment);
1465
1466 print_file(file, indent, "*(");
1467 write_type(file, var->type, var, var->tname);
1468 fprintf(file, " *)_StubMsg.Buffer = ");
1469 write_name(file, var);
1470 fprintf(file, ";\n");
1471 print_file(file, indent, "_StubMsg.Buffer += sizeof(");
1472 write_type(file, var->type, var, var->tname);
1473 fprintf(file, ");\n");
1474
1475 last_size = size;
1476 }
1477 else if (var->ptr_level == 0)
1478 {
1479 const char *ndrtype;
1480
1481 switch (var->type->type)
1482 {
1483 case RPC_FC_STRUCT:
1484 ndrtype = "SimpleStruct";
1485 break;
1486 case RPC_FC_CSTRUCT:
1487 case RPC_FC_CPSTRUCT:
1488 ndrtype = "ConformantStruct";
1489 break;
1490 case RPC_FC_CVSTRUCT:
1491 ndrtype = "ConformantVaryingStruct";
1492 break;
1493 case RPC_FC_BOGUS_STRUCT:
1494 ndrtype = "ComplexStruct";
1495 break;
1496 case RPC_FC_IGNORE:
1497 case RPC_FC_BIND_PRIMITIVE:
1498 /* no marshalling needed */
1499 continue;
1500 default:
1501 error("marshall_arguments: Unsupported type: %s (0x%02x, ptr_level: %d)\n",
1502 var->name, var->type->type, var->ptr_level);
1503 ndrtype = NULL;
1504 }
1505
1506 print_file(file, indent,
1507 "Ndr%sMarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d]);\n",
1508 ndrtype, var->name, *type_offset);
1509 last_size = 1;
1510 }
1511 else
1512 {
1513 print_file(file, indent,
1514 "NdrPointerMarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d]);\n",
1515 var->name, *type_offset);
1516 last_size = 1;
1517 }
1518 fprintf(file, "\n");
1519 }
1520 }
1521
1522 void unmarshall_arguments(FILE *file, int indent, func_t *func,
1523 unsigned int *type_offset, enum pass pass)
1524 {
1525 unsigned int last_size = 0;
1526 var_t *var;
1527
1528 if (!func->args)
1529 return;
1530
1531 var = func->args;
1532 while (NEXT_LINK(var)) var = NEXT_LINK(var);
1533 for (; var; *type_offset += get_size_typeformatstring_var(var), var = PREV_LINK(var))
1534 {
1535 int in_attr = is_attr(var->attrs, ATTR_IN);
1536 int out_attr = is_attr(var->attrs, ATTR_OUT);
1537
1538 if (!in_attr && !out_attr)
1539 in_attr = 1;
1540
1541 switch (pass)
1542 {
1543 case PASS_IN:
1544 if (!in_attr)
1545 continue;
1546 break;
1547 case PASS_OUT:
1548 if (!out_attr)
1549 continue;
1550 break;
1551 case PASS_RETURN:
1552 break;
1553 }
1554
1555 if (is_string_type(var->attrs, var->ptr_level, var->array))
1556 {
1557 if (var->array && var->array->is_const)
1558 print_file(file, indent,
1559 "NdrNonConformantStringUnmarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d], 0);\n",
1560 var->name, *type_offset);
1561 else
1562 print_file(file, indent,
1563 "NdrConformantStringUnmarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d], 0);\n",
1564 var->name, *type_offset);
1565 last_size = 1;
1566 }
1567 else if (is_array_type(var->attrs, var->ptr_level, var->array))
1568 {
1569 const expr_t *length_is = get_attrp(var->attrs, ATTR_LENGTHIS);
1570 const expr_t *size_is = get_attrp(var->attrs, ATTR_SIZEIS);
1571 const char *array_type;
1572 int has_length = length_is && (length_is->type != EXPR_VOID);
1573 int has_size = (size_is && (size_is->type != EXPR_VOID)) || !var->array->is_const;
1574
1575 if (var->array && NEXT_LINK(var->array)) /* multi-dimensional array */
1576 array_type = "ComplexArray";
1577 else
1578 {
1579 if (!has_length && !has_size)
1580 array_type = "FixedArray";
1581 else if (has_length && !has_size)
1582 array_type = "VaryingArray";
1583 else if (!has_length && has_size)
1584 array_type = "ConformantArray";
1585 else
1586 array_type = "ConformantVaryingArray";
1587 }
1588
1589 print_file(file, indent,
1590 "Ndr%sUnmarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d], 0);\n",
1591 array_type, var->name, *type_offset);
1592 last_size = 1;
1593 }
1594 else if (var->ptr_level == 0 && is_base_type(var->type->type))
1595 {
1596 unsigned int size;
1597 unsigned int alignment = 0;
1598
1599 switch (var->type->type)
1600 {
1601 case RPC_FC_BYTE:
1602 case RPC_FC_CHAR:
1603 case RPC_FC_SMALL:
1604 case RPC_FC_USMALL:
1605 size = 1;
1606 alignment = 0;
1607 break;
1608
1609 case RPC_FC_WCHAR:
1610 case RPC_FC_USHORT:
1611 case RPC_FC_SHORT:
1612 size = 2;
1613 if (last_size != 0 && last_size < 2)
1614 alignment = (2 - last_size);
1615 break;
1616
1617 case RPC_FC_ULONG:
1618 case RPC_FC_LONG:
1619 case RPC_FC_FLOAT:
1620 case RPC_FC_ERROR_STATUS_T:
1621 size = 4;
1622 if (last_size != 0 && last_size < 4)
1623 alignment = (4 - last_size);
1624 break;
1625
1626 case RPC_FC_HYPER:
1627 case RPC_FC_DOUBLE:
1628 size = 8;
1629 if (last_size != 0 && last_size < 4)
1630 alignment = (4 - last_size);
1631 break;
1632
1633 default:
1634 error("unmarshall_arguments: Unsupported type: %s (0x%02x, ptr_level: 0)\n", var->name, var->type->type);
1635 size = 0;
1636 }
1637
1638 if (alignment != 0)
1639 print_file(file, indent, "_StubMsg.Buffer += %u;\n", alignment);
1640
1641 print_file(file, indent, "");
1642 write_name(file, var);
1643 fprintf(file, " = *(");
1644 write_type(file, var->type, var, var->tname);
1645 fprintf(file, " *)_StubMsg.Buffer;\n");
1646 print_file(file, indent, "_StubMsg.Buffer += sizeof(");
1647 write_type(file, var->type, var, var->tname);
1648 fprintf(file, ");\n");
1649
1650 last_size = size;
1651 }
1652 else if (var->ptr_level == 0)
1653 {
1654 const char *ndrtype;
1655
1656 switch (var->type->type)
1657 {
1658 case RPC_FC_STRUCT:
1659 ndrtype = "SimpleStruct";
1660 break;
1661 case RPC_FC_CSTRUCT:
1662 case RPC_FC_CPSTRUCT:
1663 ndrtype = "ConformantStruct";
1664 break;
1665 case RPC_FC_CVSTRUCT:
1666 ndrtype = "ConformantVaryingStruct";
1667 break;
1668 case RPC_FC_BOGUS_STRUCT:
1669 ndrtype = "ComplexStruct";
1670 break;
1671 case RPC_FC_IGNORE:
1672 case RPC_FC_BIND_PRIMITIVE:
1673 /* no unmarshalling needed */
1674 continue;
1675 default:
1676 error("unmarshall_arguments: Unsupported type: %s (0x%02x, ptr_level: %d)\n",
1677 var->name, var->type->type, var->ptr_level);
1678 ndrtype = NULL;
1679 }
1680
1681 print_file(file, indent,
1682 "Ndr%sUnmarshall(&_StubMsg, (unsigned char *)%s, &__MIDL_TypeFormatString.Format[%d], 0);\n",
1683 ndrtype, var->name, *type_offset);
1684 last_size = 1;
1685 }
1686 else
1687 {
1688 print_file(file, indent,
1689 "NdrPointerUnmarshall(&_StubMsg, (unsigned char **)&%s, &__MIDL_TypeFormatString.Format[%d], 0);\n",
1690 var->name, *type_offset);
1691 last_size = 1;
1692 }
1693 fprintf(file, "\n");
1694 }
1695 }
1696
1697
1698 size_t get_size_procformatstring_var(const var_t *var)
1699 {
1700 unsigned int type_offset = 2;
1701 return write_procformatstring_var(NULL, 0, var, FALSE, &type_offset);
1702 }
1703
1704
1705 size_t get_size_typeformatstring_var(const var_t *var)
1706 {
1707 unsigned int type_offset = 0;
1708 write_typeformatstring_var(NULL, 0, var, &type_offset);
1709 return type_offset;
1710 }
1711
1712 static void write_struct_expr(FILE *h, const expr_t *e, int brackets,
1713 const var_t *fields, const char *structvar)
1714 {
1715 switch (e->type) {
1716 case EXPR_VOID:
1717 break;
1718 case EXPR_NUM:
1719 fprintf(h, "%ld", e->u.lval);
1720 break;
1721 case EXPR_HEXNUM:
1722 fprintf(h, "0x%lx", e->u.lval);
1723 break;
1724 case EXPR_IDENTIFIER:
1725 {
1726 const var_t *field;
1727 for (field = fields; field; field = NEXT_LINK(field))
1728 {
1729 if (!strcmp(e->u.sval, field->name))
1730 {
1731 fprintf(h, "%s->%s", structvar, e->u.sval);
1732 break;
1733 }
1734 }
1735 if (!field) error("no field found for identifier %s\n", e->u.sval);
1736 break;
1737 }
1738 case EXPR_NEG:
1739 fprintf(h, "-");
1740 write_struct_expr(h, e->ref, 1, fields, structvar);
1741 break;
1742 case EXPR_NOT:
1743 fprintf(h, "~");
1744 write_struct_expr(h, e->ref, 1, fields, structvar);
1745 break;
1746 case EXPR_PPTR:
1747 fprintf(h, "*");
1748 write_struct_expr(h, e->ref, 1, fields, structvar);
1749 break;
1750 case EXPR_CAST:
1751 fprintf(h, "(");
1752 write_type(h, e->u.tref->ref, NULL, e->u.tref->name);
1753 fprintf(h, ")");
1754 write_struct_expr(h, e->ref, 1, fields, structvar);
1755 break;
1756 case EXPR_SIZEOF:
1757 fprintf(h, "sizeof(");
1758 write_type(h, e->u.tref->ref, NULL, e->u.tref->name);
1759 fprintf(h, ")");
1760 break;
1761 case EXPR_SHL:
1762 case EXPR_SHR:
1763 case EXPR_MUL:
1764 case EXPR_DIV:
1765 case EXPR_ADD:
1766 case EXPR_SUB:
1767 case EXPR_AND:
1768 case EXPR_OR:
1769 if (brackets) fprintf(h, "(");
1770 write_struct_expr(h, e->ref, 1, fields, structvar);
1771 switch (e->type) {
1772 case EXPR_SHL: fprintf(h, " << "); break;
1773 case EXPR_SHR: fprintf(h, " >> "); break;
1774 case EXPR_MUL: fprintf(h, " * "); break;
1775 case EXPR_DIV: fprintf(h, " / "); break;
1776 case EXPR_ADD: fprintf(h, " + "); break;
1777 case EXPR_SUB: fprintf(h, " - "); break;
1778 case EXPR_AND: fprintf(h, " & "); break;
1779 case EXPR_OR: fprintf(h, " | "); break;
1780 default: break;
1781 }
1782 write_struct_expr(h, e->u.ext, 1, fields, structvar);
1783 if (brackets) fprintf(h, ")");
1784 break;
1785 case EXPR_COND:
1786 if (brackets) fprintf(h, "(");
1787 write_struct_expr(h, e->ref, 1, fields, structvar);
1788 fprintf(h, " ? ");
1789 write_struct_expr(h, e->u.ext, 1, fields, structvar);
1790 fprintf(h, " : ");
1791 write_struct_expr(h, e->ext2, 1, fields, structvar);
1792 if (brackets) fprintf(h, ")");
1793 break;
1794 }
1795 }
1796
1797 int write_expr_eval_routines(FILE *file, const char *iface)
1798 {
1799 int result = 0;
1800 struct expr_eval_routine *eval;
1801 unsigned short callback_offset = 0;
1802
1803 LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
1804 {
1805 int indent = 0;
1806 result = 1;
1807 print_file(file, indent, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
1808 iface, eval->structure->name, callback_offset);
1809 print_file(file, indent, "{\n");
1810 indent++;
1811 print_file(file, indent, "struct %s *" STRUCT_EXPR_EVAL_VAR " = (struct %s *)(pStubMsg->StackTop - %u);\n",
1812 eval->structure->name, eval->structure->name, eval->structure_size);
1813 fprintf(file, "\n");
1814 print_file(file, indent, "pStubMsg->Offset = 0;\n"); /* FIXME */
1815 print_file(file, indent, "pStubMsg->MaxCount = (unsigned long)");
1816 write_struct_expr(file, eval->expr, 1, eval->structure->fields, STRUCT_EXPR_EVAL_VAR);
1817 fprintf(file, ";\n");
1818 indent--;
1819 print_file(file, indent, "}\n\n");
1820 callback_offset++;
1821 }
1822 return result;
1823 }
1824
1825 void write_expr_eval_routine_list(FILE *file, const char *iface)
1826 {
1827 struct expr_eval_routine *eval;
1828 struct expr_eval_routine *cursor;
1829 unsigned short callback_offset = 0;
1830
1831 fprintf(file, "static const EXPR_EVAL ExprEvalRoutines[] =\n");
1832 fprintf(file, "{\n");
1833
1834 LIST_FOR_EACH_ENTRY_SAFE(eval, cursor, &expr_eval_routines, struct expr_eval_routine, entry)
1835 {
1836 print_file(file, 1, "%s_%sExprEval_%04u,\n",
1837 iface, eval->structure->name, callback_offset);
1838
1839 callback_offset++;
1840 list_remove(&eval->entry);
1841 free(eval);
1842 }
1843
1844 fprintf(file, "};\n\n");
1845 }