?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
widl: Move initialization of the stub buffer size into write_remoting_arguments().
[wine/multimedia.git] / tools / widl / typegen.c
blob1e6c2da68500b98ae881a300f8e271970eada67b
1 /*
2 * Format String Generator for IDL Compiler
3 *
4 * Copyright 2005-2006 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 array_dims_t *array);
63 static size_t fields_memsize(const var_list_t *fields);
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 case EXPR_TRUEFALSE:
77 return a->u.lval - b->u.lval;
78 case EXPR_IDENTIFIER:
79 return strcmp(a->u.sval, b->u.sval);
80 case EXPR_COND:
81 ret = compare_expr(a->ref, b->ref);
82 if (ret != 0)
83 return ret;
84 ret = compare_expr(a->u.ext, b->u.ext);
85 if (ret != 0)
86 return ret;
87 return compare_expr(a->ext2, b->ext2);
88 case EXPR_OR:
89 case EXPR_AND:
90 case EXPR_ADD:
91 case EXPR_SUB:
92 case EXPR_MUL:
93 case EXPR_DIV:
94 case EXPR_SHL:
95 case EXPR_SHR:
96 ret = compare_expr(a->ref, b->ref);
97 if (ret != 0)
98 return ret;
99 return compare_expr(a->u.ext, b->u.ext);
100 case EXPR_NOT:
101 case EXPR_NEG:
102 case EXPR_PPTR:
103 case EXPR_CAST:
104 case EXPR_SIZEOF:
105 return compare_expr(a->ref, b->ref);
106 case EXPR_VOID:
107 return 0;
108 }
109 return -1;
110 }
111
112 #define WRITE_FCTYPE(file, fctype, typestring_offset) \
113 do { \
114 if (file) \
115 fprintf(file, "/* %2u */\n", typestring_offset); \
116 print_file((file), 2, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
117 } \
118 while (0)
119
120 static int print_file(FILE *file, int indent, const char *format, ...)
121 {
122 va_list va;
123 int i, r;
124
125 if (!file) return 0;
126
127 va_start(va, format);
128 for (i = 0; i < indent; i++)
129 fprintf(file, " ");
130 r = vfprintf(file, format, va);
131 va_end(va);
132 return r;
133 }
134
135 static void write_formatdesc(FILE *f, int indent, const char *str)
136 {
137 print_file(f, indent, "typedef struct _MIDL_%s_FORMAT_STRING\n", str);
138 print_file(f, indent, "{\n");
139 print_file(f, indent + 1, "short Pad;\n");
140 print_file(f, indent + 1, "unsigned char Format[%s_FORMAT_STRING_SIZE];\n", str);
141 print_file(f, indent, "} MIDL_%s_FORMAT_STRING;\n", str);
142 print_file(f, indent, "\n");
143 }
144
145 void write_formatstringsdecl(FILE *f, int indent, ifref_list_t *ifaces, int for_objects)
146 {
147 print_file(f, indent, "#define TYPE_FORMAT_STRING_SIZE %d\n",
148 get_size_typeformatstring(ifaces, for_objects));
149
150 print_file(f, indent, "#define PROC_FORMAT_STRING_SIZE %d\n",
151 get_size_procformatstring(ifaces, for_objects));
152
153 fprintf(f, "\n");
154 write_formatdesc(f, indent, "TYPE");
155 write_formatdesc(f, indent, "PROC");
156 fprintf(f, "\n");
157 print_file(f, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;\n");
158 print_file(f, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;\n");
159 print_file(f, indent, "\n");
160 }
161
162 static inline int is_base_type(unsigned char type)
163 {
164 switch (type)
165 {
166 case RPC_FC_BYTE:
167 case RPC_FC_CHAR:
168 case RPC_FC_USMALL:
169 case RPC_FC_SMALL:
170 case RPC_FC_WCHAR:
171 case RPC_FC_USHORT:
172 case RPC_FC_SHORT:
173 case RPC_FC_ULONG:
174 case RPC_FC_LONG:
175 case RPC_FC_HYPER:
176 case RPC_FC_IGNORE:
177 case RPC_FC_FLOAT:
178 case RPC_FC_DOUBLE:
179 case RPC_FC_ENUM16:
180 case RPC_FC_ENUM32:
181 case RPC_FC_ERROR_STATUS_T:
182 case RPC_FC_BIND_PRIMITIVE:
183 return TRUE;
184
185 default:
186 return FALSE;
187 }
188 }
189
190 static size_t write_procformatstring_var(FILE *file, int indent,
191 const var_t *var, int is_return, unsigned int *type_offset)
192 {
193 size_t size;
194 int ptr_level = var->ptr_level;
195 const type_t *type = var->type;
196
197 int is_in = is_attr(var->attrs, ATTR_IN);
198 int is_out = is_attr(var->attrs, ATTR_OUT);
199
200 if (!is_in && !is_out) is_in = TRUE;
201
202 if (ptr_level == 0 && !var->array && is_base_type(type->type))
203 {
204 if (is_return)
205 print_file(file, indent, "0x53, /* FC_RETURN_PARAM_BASETYPE */\n");
206 else
207 print_file(file, indent, "0x4e, /* FC_IN_PARAM_BASETYPE */\n");
208
209 switch(type->type)
210 {
211 #define CASE_BASETYPE(fctype) \
212 case RPC_##fctype: \
213 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
214 size = 2; /* includes param type prefix */ \
215 break
216
217 CASE_BASETYPE(FC_BYTE);
218 CASE_BASETYPE(FC_CHAR);
219 CASE_BASETYPE(FC_WCHAR);
220 CASE_BASETYPE(FC_USHORT);
221 CASE_BASETYPE(FC_SHORT);
222 CASE_BASETYPE(FC_ULONG);
223 CASE_BASETYPE(FC_LONG);
224 CASE_BASETYPE(FC_HYPER);
225 CASE_BASETYPE(FC_IGNORE);
226 CASE_BASETYPE(FC_USMALL);
227 CASE_BASETYPE(FC_SMALL);
228 CASE_BASETYPE(FC_FLOAT);
229 CASE_BASETYPE(FC_DOUBLE);
230 CASE_BASETYPE(FC_ERROR_STATUS_T);
231 #undef CASE_BASETYPE
232
233 case RPC_FC_BIND_PRIMITIVE:
234 print_file(file, indent, "0x%02x, /* FC_IGNORE */\n", RPC_FC_IGNORE);
235 size = 2; /* includes param type prefix */
236 break;
237
238 default:
239 error("Unknown/unsupported type: %s (0x%02x)\n", var->name, type->type);
240 size = 0;
241 }
242 }
243 else
244 {
245 if (is_return)
246 print_file(file, indent, "0x52, /* FC_RETURN_PARAM */\n");
247 else if (is_in && is_out)
248 print_file(file, indent, "0x50, /* FC_IN_OUT_PARAM */\n");
249 else if (is_out)
250 print_file(file, indent, "0x51, /* FC_OUT_PARAM */\n");
251 else
252 print_file(file, indent, "0x4d, /* FC_IN_PARAM */\n");
253
254 print_file(file, indent, "0x01,\n");
255 print_file(file, indent, "NdrFcShort(0x%x),\n", *type_offset);
256 size = 4; /* includes param type prefix */
257 }
258 *type_offset += get_size_typeformatstring_var(var);
259 return size;
260 }
261
262 void write_procformatstring(FILE *file, const ifref_list_t *ifaces, int for_objects)
263 {
264 const ifref_t *iface;
265 int indent = 0;
266 const var_t *var;
267 unsigned int type_offset = 2;
268
269 print_file(file, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
270 print_file(file, indent, "{\n");
271 indent++;
272 print_file(file, indent, "0,\n");
273 print_file(file, indent, "{\n");
274 indent++;
275
276 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
277 {
278 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
279 continue;
280
281 if (iface->iface->funcs)
282 {
283 const func_t *func;
284 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
285 {
286 /* emit argument data */
287 if (func->args)
288 {
289 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
290 write_procformatstring_var(file, indent, var, FALSE, &type_offset);
291 }
292
293 /* emit return value data */
294 var = func->def;
295 if (is_void(var->type, NULL))
296 {
297 print_file(file, indent, "0x5b, /* FC_END */\n");
298 print_file(file, indent, "0x5c, /* FC_PAD */\n");
299 }
300 else
301 write_procformatstring_var(file, indent, var, TRUE,
302 &type_offset);
303 }
304 }
305 }
306
307 print_file(file, indent, "0x0\n");
308 indent--;
309 print_file(file, indent, "}\n");
310 indent--;
311 print_file(file, indent, "};\n");
312 print_file(file, indent, "\n");
313 }
314
315 /* write conformance / variance descriptor */
316 static size_t write_conf_or_var_desc(FILE *file, const func_t *func, const type_t *structure, const expr_t *expr)
317 {
318 unsigned char operator_type = 0;
319 const char *operator_string = "no operators";
320 const expr_t *subexpr = expr;
321 unsigned char correlation_type;
322
323 if (!file) return 4; /* optimisation for sizing pass */
324
325 if (expr->is_const)
326 {
327 if (expr->cval > UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX)
328 error("write_conf_or_var_desc: constant value %ld is greater than "
329 "the maximum constant size of %d\n", expr->cval,
330 UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX);
331
332 print_file(file, 2, "0x%x, /* Corr desc: constant, val = %ld */\n",
333 RPC_FC_CONSTANT_CONFORMANCE, expr->cval);
334 print_file(file, 2, "0x%x,\n", expr->cval & ~USHRT_MAX);
335 print_file(file, 2, "NdrFcShort(0x%x),\n", expr->cval & USHRT_MAX);
336
337 return 4;
338 }
339
340 switch (subexpr->type)
341 {
342 case EXPR_PPTR:
343 subexpr = subexpr->ref;
344 operator_type = RPC_FC_DEREFERENCE;
345 operator_string = "FC_DEREFERENCE";
346 break;
347 case EXPR_DIV:
348 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
349 {
350 subexpr = subexpr->ref;
351 operator_type = RPC_FC_DIV_2;
352 operator_string = "FC_DIV_2";
353 }
354 break;
355 case EXPR_MUL:
356 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
357 {
358 subexpr = subexpr->ref;
359 operator_type = RPC_FC_MULT_2;
360 operator_string = "FC_MULT_2";
361 }
362 break;
363 case EXPR_SUB:
364 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
365 {
366 subexpr = subexpr->ref;
367 operator_type = RPC_FC_SUB_1;
368 operator_string = "FC_SUB_1";
369 }
370 break;
371 case EXPR_ADD:
372 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
373 {
374 subexpr = subexpr->ref;
375 operator_type = RPC_FC_ADD_1;
376 operator_string = "FC_ADD_1";
377 }
378 break;
379 default:
380 break;
381 }
382
383 if (subexpr->type == EXPR_IDENTIFIER)
384 {
385 const type_t *correlation_variable = NULL;
386 unsigned char correlation_variable_type;
387 unsigned char param_type = 0;
388 const char *param_type_string = NULL;
389 size_t offset;
390
391 if (structure)
392 {
393 const var_t *var;
394
395 offset = 0;
396 if (structure->fields) LIST_FOR_EACH_ENTRY( var, structure->fields, const var_t, entry )
397 {
398 offset -= type_memsize(var->type, var->ptr_level, var->array);
399 if (!strcmp(var->name, subexpr->u.sval))
400 {
401 correlation_variable = var->type;
402 break;
403 }
404 }
405 if (!correlation_variable)
406 error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
407 subexpr->u.sval);
408
409 correlation_type = RPC_FC_NORMAL_CONFORMANCE;
410 }
411 else
412 {
413 const var_t *var;
414
415 offset = 0;
416 if (func->args) LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
417 {
418 if (!strcmp(var->name, subexpr->u.sval))
419 {
420 correlation_variable = var->type;
421 break;
422 }
423 /* FIXME: not all stack variables are sizeof(void *) */
424 offset += sizeof(void *);
425 }
426 if (!correlation_variable)
427 error("write_conf_or_var_desc: couldn't find variable %s in function\n",
428 subexpr->u.sval);
429
430 correlation_type = RPC_FC_TOP_LEVEL_CONFORMANCE;
431 }
432
433 correlation_variable_type = correlation_variable->type;
434
435 switch (correlation_variable_type)
436 {
437 case RPC_FC_CHAR:
438 case RPC_FC_SMALL:
439 param_type = RPC_FC_SMALL;
440 param_type_string = "FC_SMALL";
441 break;
442 case RPC_FC_BYTE:
443 case RPC_FC_USMALL:
444 param_type = RPC_FC_USMALL;
445 param_type_string = "FC_USMALL";
446 break;
447 case RPC_FC_WCHAR:
448 case RPC_FC_SHORT:
449 param_type = RPC_FC_SHORT;
450 param_type_string = "FC_SHORT";
451 break;
452 case RPC_FC_USHORT:
453 param_type = RPC_FC_USHORT;
454 param_type_string = "FC_USHORT";
455 break;
456 case RPC_FC_LONG:
457 param_type = RPC_FC_LONG;
458 param_type_string = "FC_LONG";
459 break;
460 case RPC_FC_ULONG:
461 param_type = RPC_FC_ULONG;
462 param_type_string = "FC_ULONG";
463 break;
464 default:
465 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n",
466 correlation_variable_type);
467 }
468
469 print_file(file, 2, "0x%x, /* Corr desc: %s%s */\n",
470 correlation_type | param_type,
471 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "parameter, " : "",
472 param_type_string);
473 print_file(file, 2, "0x%x, /* %s */\n", operator_type, operator_string);
474 print_file(file, 2, "NdrFcShort(0x%x), /* %soffset = %d */\n",
475 offset,
476 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "x86 stack size / " : "",
477 offset);
478 }
479 else
480 {
481 unsigned int callback_offset = 0;
482
483 if (structure)
484 {
485 struct expr_eval_routine *eval;
486 int found = 0;
487
488 LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
489 {
490 if (!strcmp(eval->structure->name, structure->name) &&
491 !compare_expr(eval->expr, expr))
492 {
493 found = 1;
494 break;
495 }
496 callback_offset++;
497 }
498
499 if (!found)
500 {
501 eval = xmalloc(sizeof(*eval));
502 eval->structure = structure;
503 eval->structure_size = fields_memsize(structure->fields);
504 eval->expr = expr;
505 list_add_tail(&expr_eval_routines, &eval->entry);
506 }
507
508 correlation_type = RPC_FC_NORMAL_CONFORMANCE;
509 }
510 else
511 {
512 error("write_conf_or_var_desc: top-level callback conformance unimplemented\n");
513 correlation_type = RPC_FC_TOP_LEVEL_CONFORMANCE;
514 }
515
516 if (callback_offset > USHRT_MAX)
517 error("Maximum number of callback routines reached\n");
518
519 print_file(file, 2, "0x%x, /* Corr desc: %s */\n",
520 correlation_type,
521 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "parameter" : "");
522 print_file(file, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK");
523 print_file(file, 2, "NdrFcShort(0x%x), /* %u */\n", callback_offset, callback_offset);
524 }
525 return 4;
526 }
527
528 static size_t fields_memsize(const var_list_t *fields)
529 {
530 size_t size = 0;
531 const var_t *v;
532
533 if (!fields) return 0;
534 LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
535 size += type_memsize(v->type, v->ptr_level, v->array);
536
537 return size;
538 }
539
540 static size_t type_memsize(const type_t *t, int ptr_level, const array_dims_t *array)
541 {
542 size_t size = 0;
543
544 if (ptr_level)
545 return sizeof(void *);
546
547 switch (t->type)
548 {
549 case RPC_FC_BYTE:
550 case RPC_FC_CHAR:
551 case RPC_FC_USMALL:
552 case RPC_FC_SMALL:
553 size = 1;
554 break;
555 case RPC_FC_WCHAR:
556 case RPC_FC_USHORT:
557 case RPC_FC_SHORT:
558 case RPC_FC_ENUM16:
559 size = 2;
560 break;
561 case RPC_FC_ULONG:
562 case RPC_FC_LONG:
563 case RPC_FC_ERROR_STATUS_T:
564 case RPC_FC_ENUM32:
565 case RPC_FC_FLOAT:
566 size = 4;
567 break;
568 case RPC_FC_HYPER:
569 case RPC_FC_DOUBLE:
570 size = 8;
571 break;
572 case RPC_FC_STRUCT:
573 case RPC_FC_CVSTRUCT:
574 case RPC_FC_CPSTRUCT:
575 case RPC_FC_CSTRUCT:
576 case RPC_FC_PSTRUCT:
577 case RPC_FC_BOGUS_STRUCT:
578 case RPC_FC_ENCAPSULATED_UNION:
579 case RPC_FC_NON_ENCAPSULATED_UNION:
580 size = fields_memsize(t->fields);
581 break;
582 default:
583 error("type_memsize: Unknown type %d\n", t->type);
584 size = 0;
585 }
586
587 if (array)
588 {
589 expr_t *dim;
590 LIST_FOR_EACH_ENTRY( dim, array, expr_t, entry )
591 if (dim->is_const)
592 size *= dim->cval;
593 else
594 size = 0;
595 }
596
597 return size;
598 }
599
600 size_t get_type_memsize(const type_t *type)
601 {
602 return type_memsize(type, 0, NULL);
603 }
604
605 static int write_pointers(FILE *file, const attr_list_t *attrs,
606 const type_t *type, int ptr_level,
607 const array_dims_t *array, int level,
608 unsigned int *typestring_offset)
609 {
610 int pointers_written = 0;
611 const var_t *v;
612
613 /* don't generate a pointer for first-level arrays since we want to
614 * descend into them to write their pointers, not stop here */
615 if ((level == 0 || ptr_level == 0) && is_array_type(attrs, ptr_level, array))
616 {
617 return write_pointers(file, NULL, type, 0, NULL, level + 1, typestring_offset);
618 }
619
620 if (ptr_level != 0)
621 {
622 /* FIXME: only general algorithm implemented, not the actual writing */
623 error("write_pointers: Writing type format string for pointer is unimplemented\n");
624 return 1;
625 }
626
627 switch (type->type)
628 {
629 /* note: don't descend into complex structures or unions since these
630 * will always be generated as a separate type */
631 case RPC_FC_STRUCT:
632 case RPC_FC_CVSTRUCT:
633 case RPC_FC_CPSTRUCT:
634 case RPC_FC_CSTRUCT:
635 case RPC_FC_PSTRUCT:
636 if (!type->fields) break;
637 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
638 pointers_written += write_pointers(file, v->attrs, v->type,
639 v->ptr_level, v->array,
640 level + 1,
641 typestring_offset);
642
643 break;
644
645 default:
646 /* nothing to do */
647 break;
648 }
649
650 return pointers_written;
651 }
652
653 static size_t write_pointer_description(FILE *file, const attr_list_t *attrs,
654 const type_t *type, int ptr_level,
655 const array_dims_t *array, int level,
656 size_t typestring_offset)
657 {
658 size_t size = 0;
659 const var_t *v;
660
661 /* don't generate a pointer for first-level arrays since we want to
662 * descend into them to write their pointers, not stop here */
663 if ((level == 0 || ptr_level == 0) && is_array_type(attrs, ptr_level, array))
664 {
665 return write_pointer_description(file, NULL, type, 0, NULL,
666 level + 1, typestring_offset);
667 }
668
669 if (ptr_level != 0)
670 {
671 /* FIXME: only general algorithm implemented, not the actual writing */
672 error("write_pointer_description: Writing pointer description is unimplemented\n");
673 return 0;
674 }
675
676 /* FIXME: search through all refs for pointers too */
677
678 switch (type->type)
679 {
680 /* note: don't descend into complex structures or unions since these
681 * will always be generated as a separate type */
682 case RPC_FC_STRUCT:
683 case RPC_FC_CVSTRUCT:
684 case RPC_FC_CPSTRUCT:
685 case RPC_FC_CSTRUCT:
686 case RPC_FC_PSTRUCT:
687 if (!type->fields) break;
688 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
689 size += write_pointer_description(file, v->attrs, v->type,
690 v->ptr_level, v->array,
691 level + 1,
692 typestring_offset);
693
694 break;
695
696 default:
697 /* nothing to do */
698 break;
699 }
700
701 return size;
702 }
703
704 static size_t write_string_tfs(FILE *file, const attr_list_t *attrs,
705 const type_t *type, const array_dims_t *array,
706 const char *name, unsigned int *typestring_offset)
707 {
708 const expr_t *size_is = get_attrp(attrs, ATTR_SIZEIS);
709 int has_size = size_is && (size_is->type != EXPR_VOID);
710 size_t start_offset = *typestring_offset;
711 unsigned char flags = 0;
712 int pointer_type;
713 unsigned char rtype;
714
715 if (is_ptr(type))
716 {
717 pointer_type = type->type;
718 type = type->ref;
719 }
720 else
721 pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
722
723 if (!pointer_type)
724 pointer_type = RPC_FC_RP;
725
726 if (!get_attrp(attrs, ATTR_SIZEIS))
727 flags |= RPC_FC_P_SIMPLEPOINTER;
728
729 rtype = type->type;
730
731 if ((rtype != RPC_FC_BYTE) && (rtype != RPC_FC_CHAR) && (rtype != RPC_FC_WCHAR))
732 {
733 error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", rtype, name);
734 return start_offset;
735 }
736
737 print_file(file, 2,"0x%x, 0x%x, /* %s%s */\n",
738 pointer_type, flags,
739 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"),
740 (flags & RPC_FC_P_SIMPLEPOINTER) ? " [simple_pointer]" : "");
741 *typestring_offset += 2;
742
743 if (!(flags & RPC_FC_P_SIMPLEPOINTER))
744 {
745 print_file(file, 2, "NdrFcShort(0x2),\n");
746 *typestring_offset += 2;
747 }
748
749 if (array && !is_conformant_array(array))
750 {
751 /* FIXME: multi-dimensional array */
752 const expr_t *dim = LIST_ENTRY( list_head( array ), expr_t, entry );
753 if (dim->cval > USHRT_MAX)
754 error("array size for parameter %s exceeds %d bytes by %ld bytes\n",
755 name, USHRT_MAX, dim->cval - USHRT_MAX);
756
757 if (rtype == RPC_FC_CHAR)
758 WRITE_FCTYPE(file, FC_CSTRING, *typestring_offset);
759 else
760 WRITE_FCTYPE(file, FC_WSTRING, *typestring_offset);
761 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
762 *typestring_offset += 2;
763
764 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", dim->cval, dim->cval);
765 *typestring_offset += 2;
766
767 return start_offset;
768 }
769 else if (has_size)
770 {
771 if (rtype == RPC_FC_CHAR)
772 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
773 else
774 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
775 print_file(file, 2, "0x%x, /* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED);
776 *typestring_offset += 2;
777
778 *typestring_offset += write_conf_or_var_desc(file, current_func, NULL, size_is);
779
780 return start_offset;
781 }
782 else
783 {
784 if (rtype == RPC_FC_CHAR)
785 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
786 else
787 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
788 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
789 *typestring_offset += 2;
790
791 return start_offset;
792 }
793 }
794
795 static size_t write_array_tfs(FILE *file, const attr_list_t *attrs,
796 const type_t *type, const array_dims_t *array,
797 const char *name, unsigned int *typestring_offset)
798 {
799 const expr_t *length_is = get_attrp(attrs, ATTR_LENGTHIS);
800 const expr_t *size_is = get_attrp(attrs, ATTR_SIZEIS);
801 int has_length = length_is && (length_is->type != EXPR_VOID);
802 int has_size = (size_is && (size_is->type != EXPR_VOID)) || is_conformant_array(array);
803 size_t start_offset;
804 int pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
805 if (!pointer_type)
806 pointer_type = RPC_FC_RP;
807
808 print_file(file, 2, "0x%x, 0x00, /* %s */\n",
809 pointer_type,
810 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"));
811 print_file(file, 2, "NdrFcShort(0x2),\n");
812 *typestring_offset += 4;
813
814 if (array && list_count(array) > 1) /* multi-dimensional array */
815 {
816 error("write_array_tfs: Multi-dimensional arrays not implemented yet (param %s)\n", name);
817 return 0;
818 }
819 else
820 {
821 const expr_t *dim = LIST_ENTRY( list_head( array ), expr_t, entry );
822 size_t pointer_start_offset = *typestring_offset;
823 int has_pointer = 0;
824
825 if (write_pointers(file, attrs, type, 0, array, 0, typestring_offset) > 0)
826 has_pointer = 1;
827
828 start_offset = *typestring_offset;
829
830 if (!has_length && !has_size)
831 {
832 /* fixed array */
833 size_t size = type_memsize(type, 0, array);
834 if (size < USHRT_MAX)
835 {
836 WRITE_FCTYPE(file, FC_SMFARRAY, *typestring_offset);
837 /* alignment */
838 print_file(file, 2, "0x%x, /* 0 */\n", 0);
839 /* size */
840 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", size, size);
841 *typestring_offset += 4;
842 }
843 else
844 {
845 WRITE_FCTYPE(file, FC_LGFARRAY, *typestring_offset);
846 /* alignment */
847 print_file(file, 2, "0x%x, /* 0 */\n", 0);
848 /* size */
849 print_file(file, 2, "NdrFcLong(0x%x), /* %d */\n", size, size);
850 *typestring_offset += 6;
851 }
852
853 if (has_pointer)
854 {
855 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
856 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
857 *typestring_offset += 2;
858 *typestring_offset = write_pointer_description(file, attrs,
859 type, 0, array, 0, pointer_start_offset);
860 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
861 *typestring_offset += 1;
862 }
863
864 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
865 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
866 *typestring_offset += 2;
867
868 return start_offset;
869 }
870 else if (has_length && !has_size)
871 {
872 /* varying array */
873 size_t element_size = type_memsize(type, 0, NULL);
874 size_t elements = dim->cval;
875 size_t total_size = element_size * elements;
876
877 if (total_size < USHRT_MAX)
878 {
879 WRITE_FCTYPE(file, FC_SMVARRAY, *typestring_offset);
880 /* alignment */
881 print_file(file, 2, "0x%x, /* 0 */\n", 0);
882 /* total size */
883 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", total_size, total_size);
884 /* number of elements */
885 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", elements, elements);
886 *typestring_offset += 6;
887 }
888 else
889 {
890 WRITE_FCTYPE(file, FC_LGVARRAY, *typestring_offset);
891 /* alignment */
892 print_file(file, 2, "0x%x, /* 0 */\n", 0);
893 /* total size */
894 print_file(file, 2, "NdrFcLong(0x%x), /* %d */\n", total_size, total_size);
895 /* number of elements */
896 print_file(file, 2, "NdrFcLong(0x%x), /* %d */\n", elements, elements);
897 *typestring_offset += 10;
898 }
899 /* element size */
900 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", element_size, element_size);
901 *typestring_offset += 2;
902
903 *typestring_offset += write_conf_or_var_desc(file, current_func,
904 current_structure,
905 length_is);
906
907 if (has_pointer)
908 {
909 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
910 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
911 *typestring_offset += 2;
912 *typestring_offset += write_pointer_description(file, attrs,
913 type, 0, array, 0, pointer_start_offset);
914 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
915 *typestring_offset += 1;
916 }
917
918 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
919 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
920 *typestring_offset += 2;
921
922 return start_offset;
923 }
924 else if (!has_length && has_size)
925 {
926 /* conformant array */
927 size_t element_size = type_memsize(type, 0, NULL);
928
929 WRITE_FCTYPE(file, FC_CARRAY, *typestring_offset);
930 /* alignment */
931 print_file(file, 2, "0x%x, /* 0 */\n", 0);
932 /* element size */
933 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", element_size, element_size);
934 *typestring_offset += 4;
935
936 *typestring_offset += write_conf_or_var_desc(file, current_func,
937 current_structure,
938 size_is ? size_is : dim);
939
940 if (has_pointer)
941 {
942 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
943 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
944 *typestring_offset += 2;
945 *typestring_offset += write_pointer_description(file, attrs,
946 type, 0, array, 0, pointer_start_offset);
947 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
948 *typestring_offset += 1;
949 }
950
951 print_file(file, 2, "0x%x, /* FIXME: write out conversion data */\n", type->type);
952 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
953 *typestring_offset += 2;
954
955 return start_offset;
956 }
957 else
958 {
959 /* conformant varying array */
960 size_t element_size = type_memsize(type, 0, NULL);
961
962 WRITE_FCTYPE(file, FC_CVARRAY, *typestring_offset);
963 /* alignment */
964 print_file(file, 2, "0x%x, /* 0 */\n", 0);
965 /* element size */
966 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", element_size, element_size);
967 *typestring_offset += 4;
968
969 *typestring_offset += write_conf_or_var_desc(file, current_func,
970 current_structure,
971 size_is ? size_is : dim);
972 *typestring_offset += write_conf_or_var_desc(file, current_func,
973 current_structure,
974 length_is);
975
976 if (has_pointer)
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, attrs,
982 type, 0, array, 0, pointer_start_offset);
983 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
984 *typestring_offset += 1;
985 }
986
987 print_file(file, 2, "0x0, /* FIXME: write out conversion data */\n");
988 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
989 *typestring_offset += 2;
990
991 return start_offset;
992 }
993 }
994 }
995
996 static const var_t *find_array_or_string_in_struct(const type_t *type)
997 {
998 const var_t *last_field = LIST_ENTRY( list_tail(type->fields), const var_t, entry );
999
1000 if (is_array_type(last_field->attrs, last_field->ptr_level, last_field->array))
1001 return last_field;
1002
1003 assert((last_field->type->type == RPC_FC_CSTRUCT) ||
1004 (last_field->type->type == RPC_FC_CPSTRUCT) ||
1005 (last_field->type->type == RPC_FC_CVSTRUCT));
1006
1007 return find_array_or_string_in_struct(last_field->type);
1008 }
1009
1010 static size_t write_struct_members(FILE *file, const type_t *type)
1011 {
1012 size_t typestring_size = 0;
1013 const var_t *field;
1014
1015 if (type->fields) LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
1016 {
1017 unsigned char rtype = field->type->type;
1018
1019 if (is_base_type(rtype))
1020 {
1021 switch (rtype)
1022 {
1023 #define CASE_BASETYPE(fctype) \
1024 case RPC_##fctype: \
1025 print_file(file, 2, "0x%02x,\t\t/* " #fctype " */\n", RPC_##fctype); \
1026 typestring_size++; \
1027 break;
1028 CASE_BASETYPE(FC_BYTE);
1029 CASE_BASETYPE(FC_CHAR);
1030 CASE_BASETYPE(FC_SMALL);
1031 CASE_BASETYPE(FC_USMALL);
1032 CASE_BASETYPE(FC_WCHAR);
1033 CASE_BASETYPE(FC_SHORT);
1034 CASE_BASETYPE(FC_USHORT);
1035 CASE_BASETYPE(FC_LONG);
1036 CASE_BASETYPE(FC_ULONG);
1037 CASE_BASETYPE(FC_FLOAT);
1038 CASE_BASETYPE(FC_HYPER);
1039 CASE_BASETYPE(FC_DOUBLE);
1040 CASE_BASETYPE(FC_ENUM16);
1041 CASE_BASETYPE(FC_ENUM32);
1042 CASE_BASETYPE(FC_IGNORE);
1043 CASE_BASETYPE(FC_ERROR_STATUS_T);
1044 default:
1045 break;
1046 #undef CASE_BASETYPE
1047 }
1048 }
1049 else
1050 error("Unsupported member type 0x%x\n", rtype);
1051 }
1052
1053 if (typestring_size % 1)
1054 {
1055 print_file(file, 2, "0x%x,\t\t/* FC_PAD */\n", RPC_FC_PAD);
1056 typestring_size++;
1057 }
1058
1059 print_file(file, 2, "0x%x,\t\t/* FC_END */\n", RPC_FC_END);
1060 typestring_size++;
1061
1062 return typestring_size;
1063 }
1064
1065 static size_t write_struct_tfs(FILE *file, const type_t *type,
1066 const char *name, unsigned int *typestring_offset)
1067 {
1068 unsigned int total_size;
1069 const var_t *array;
1070 size_t start_offset;
1071 size_t array_offset;
1072 size_t pointer_offset;
1073
1074 switch (type->type)
1075 {
1076 case RPC_FC_STRUCT:
1077 case RPC_FC_PSTRUCT:
1078 total_size = type_memsize(type, 0, NULL);
1079
1080 if (total_size > USHRT_MAX)
1081 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1082 name, USHRT_MAX, total_size - USHRT_MAX);
1083
1084 if (type->type == RPC_FC_PSTRUCT)
1085 {
1086 pointer_offset = *typestring_offset;
1087 write_pointers(file, NULL, type, 0, NULL, 0, typestring_offset);
1088 }
1089 else pointer_offset = 0; /* silence warning */
1090
1091 start_offset = *typestring_offset;
1092 if (type->type == RPC_FC_STRUCT)
1093 WRITE_FCTYPE(file, FC_STRUCT, *typestring_offset);
1094 else
1095 WRITE_FCTYPE(file, FC_PSTRUCT, *typestring_offset);
1096 /* alignment */
1097 print_file(file, 2, "0x3,\n"); /* FIXME */
1098 /* total size */
1099 print_file(file, 2, "NdrFcShort(0x%x), /* %u */\n", total_size, total_size);
1100 *typestring_offset += 4;
1101
1102 if (type->type == RPC_FC_PSTRUCT)
1103 {
1104 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1105 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1106 *typestring_offset += 2;
1107 *typestring_offset += write_pointer_description(file, NULL,
1108 type, 0, NULL, 0, pointer_offset);
1109 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1110 *typestring_offset += 1;
1111 }
1112
1113 /* member layout */
1114 *typestring_offset += write_struct_members(file, type);
1115 return start_offset;
1116 case RPC_FC_CSTRUCT:
1117 case RPC_FC_CPSTRUCT:
1118 total_size = type_memsize(type, 0, NULL);
1119
1120 if (total_size > USHRT_MAX)
1121 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1122 name, USHRT_MAX, total_size - USHRT_MAX);
1123
1124 array = find_array_or_string_in_struct(type);
1125 current_structure = type;
1126 array_offset = write_array_tfs(file, array->attrs, array->type,
1127 array->array, array->name,
1128 typestring_offset);
1129 current_structure = NULL;
1130
1131 if (type->type == RPC_FC_CPSTRUCT)
1132 {
1133 pointer_offset = *typestring_offset;
1134 write_pointers(file, NULL, type, 0, NULL, 0, typestring_offset);
1135 }
1136 else pointer_offset = 0; /* silence warning */
1137
1138 start_offset = *typestring_offset;
1139 if (type->type == RPC_FC_CSTRUCT)
1140 WRITE_FCTYPE(file, FC_CSTRUCT, *typestring_offset);
1141 else
1142 WRITE_FCTYPE(file, FC_CPSTRUCT, *typestring_offset);
1143 /* alignment */
1144 print_file(file, 2, "0x0,\n");
1145 /* total size */
1146 print_file(file, 2, "NdrFcShort(0x%x), /* %u */\n", total_size, total_size);
1147 *typestring_offset += 4;
1148 print_file(file, 2, "NdrFcShort(0x%x), /* offset = %d (%u) */\n",
1149 array_offset - *typestring_offset,
1150 array_offset - *typestring_offset,
1151 array_offset);
1152 *typestring_offset += 2;
1153
1154 if (type->type == RPC_FC_CPSTRUCT)
1155 {
1156 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1157 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1158 *typestring_offset += 2;
1159 *typestring_offset += write_pointer_description(file, NULL,
1160 type, 0, NULL, 0, pointer_offset);
1161 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1162 *typestring_offset += 1;
1163 }
1164
1165 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1166 *typestring_offset += 1;
1167
1168 return start_offset;
1169 case RPC_FC_CVSTRUCT:
1170 total_size = type_memsize(type, 0, NULL);
1171
1172 if (total_size > USHRT_MAX)
1173 error("structure size for parameter %s exceeds %d bytes by %d bytes\n",
1174 name, USHRT_MAX, total_size - USHRT_MAX);
1175
1176 array = find_array_or_string_in_struct(type);
1177 current_structure = type;
1178 if (is_attr(array->attrs, ATTR_STRING))
1179 array_offset = write_string_tfs(file, array->attrs, array->type,
1180 array->array, array->name,
1181 typestring_offset);
1182 else
1183 array_offset = write_array_tfs(file, array->attrs, array->type,
1184 array->array, array->name,
1185 typestring_offset);
1186 current_structure = NULL;
1187
1188 pointer_offset = *typestring_offset;
1189 if (!write_pointers(file, NULL, type, 0, NULL, 0, typestring_offset))
1190 pointer_offset = 0;
1191
1192 start_offset = *typestring_offset;
1193 WRITE_FCTYPE(file, FC_CVSTRUCT, *typestring_offset);
1194 /* alignment */
1195 print_file(file, 2, "0x0,\n");
1196 /* total size */
1197 print_file(file, 2, "NdrFcShort(0x%x), /* %u */\n", total_size, total_size);
1198 *typestring_offset += 4;
1199 print_file(file, 2, "NdrFcShort(0x%x), /* offset = %d (%u) */\n",
1200 array_offset - *typestring_offset,
1201 array_offset - *typestring_offset,
1202 array_offset);
1203 *typestring_offset += 2;
1204
1205 if (pointer_offset != 0)
1206 {
1207 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1208 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1209 *typestring_offset += 2;
1210 *typestring_offset += write_pointer_description(file, NULL,
1211 type, 0, NULL, 0, pointer_offset);
1212 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1213 *typestring_offset += 1;
1214 }
1215
1216 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1217 *typestring_offset += 1;
1218
1219 return start_offset;
1220 default:
1221 error("write_struct_tfs: Unimplemented for type 0x%x\n", type->type);
1222 return *typestring_offset;
1223 }
1224 }
1225
1226 static void write_pointer_only_tfs(FILE *file, const attr_list_t *attrs, int pointer_type,
1227 unsigned char flags, size_t offset,
1228 unsigned int *typeformat_offset)
1229 {
1230 int in_attr, out_attr;
1231 in_attr = is_attr(attrs, ATTR_IN);
1232 out_attr = is_attr(attrs, ATTR_OUT);
1233 if (!in_attr && !out_attr) in_attr = 1;
1234
1235 if (out_attr && !in_attr && pointer_type == RPC_FC_RP)
1236 flags |= 0x04;
1237
1238 print_file(file, 2, "0x%x, 0x%x,\t\t/* %s",
1239 pointer_type,
1240 flags,
1241 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"));
1242 if (file)
1243 {
1244 if (flags & 0x04)
1245 fprintf(file, " [allocated_on_stack]");
1246 if (flags & 0x10)
1247 fprintf(file, " [pointer_deref]");
1248 fprintf(file, " */\n");
1249 }
1250
1251 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", offset, offset);
1252 *typeformat_offset += 4;
1253 }
1254
1255 static size_t write_union_tfs(FILE *file, const attr_list_t *attrs,
1256 const type_t *type, const char *name,
1257 unsigned int *typeformat_offset)
1258 {
1259 error("write_union_tfs: Unimplemented\n");
1260 return *typeformat_offset;
1261 }
1262
1263 static size_t write_ip_tfs(FILE *file, const attr_list_t *attrs,
1264 const char *name, unsigned int *typeformat_offset)
1265 {
1266 size_t i;
1267 size_t start_offset = *typeformat_offset;
1268 const UUID *uuid = get_attrp(attrs, ATTR_UUID);
1269
1270 if (! uuid)
1271 error("%s: interface %s missing UUID\n", __FUNCTION__, name);
1272
1273 print_file(file, 2, "0x2f,\t/* FC_IP */\n");
1274 print_file(file, 2, "0x5a,\t/* FC_CONSTANT_IID */\n");
1275 print_file(file, 2, "NdrFcLong(0x%08lx),\n", uuid->Data1);
1276 print_file(file, 2, "NdrFcShort(0x%04x),\n", uuid->Data2);
1277 print_file(file, 2, "NdrFcShort(0x%04x),\n", uuid->Data3);
1278 for (i = 0; i < 8; ++i)
1279 print_file(file, 2, "0x%02x,\n", uuid->Data4[i]);
1280
1281 if (file)
1282 fprintf(file, "\n");
1283
1284 *typeformat_offset += 18;
1285 return start_offset;
1286 }
1287
1288 static int get_ptr_attr(const type_t *t, int def_type)
1289 {
1290 while (TRUE)
1291 {
1292 int ptr_attr = get_attrv(t->attrs, ATTR_POINTERTYPE);
1293 if (ptr_attr)
1294 return ptr_attr;
1295 if (t->kind != TKIND_ALIAS)
1296 return def_type;
1297 t = t->orig;
1298 }
1299 }
1300
1301 static size_t write_typeformatstring_var(FILE *file, int indent,
1302 const var_t *var, unsigned int *typeformat_offset)
1303 {
1304 const type_t *type = var->type;
1305 int var_ptrs = var->ptr_level, type_ptrs = 0;
1306 int is_str = is_attr(var->attrs, ATTR_STRING);
1307
1308 chat("write_typeformatstring_var: %s\n", var->name);
1309
1310 while (TRUE)
1311 {
1312 is_str = is_str || is_attr(type->attrs, ATTR_STRING);
1313 if (type->kind == TKIND_ALIAS)
1314 type = type->orig;
1315 else if (is_ptr(type))
1316 {
1317 ++type_ptrs;
1318 type = type->ref;
1319 }
1320 else
1321 {
1322 type = var->type;
1323 break;
1324 }
1325 }
1326
1327 while (TRUE)
1328 {
1329 int ptr_level = var_ptrs + type_ptrs;
1330 int pointer_type = 0;
1331
1332 chat("write_typeformatstring: type->type = 0x%x, type->name = %s, ptr_level = %d\n", type->type, type->name, ptr_level);
1333
1334 /* var attrs only effect the rightmost pointer */
1335 if ((0 < var->ptr_level && var_ptrs == var->ptr_level)
1336 || (var->ptr_level == 0 && type == var->type))
1337 {
1338 int pointer_attr = get_attrv(var->attrs, ATTR_POINTERTYPE);
1339 if (pointer_attr)
1340 {
1341 if (! ptr_level)
1342 error("'%s': pointer attribute applied to non-pointer type",
1343 var->name);
1344 pointer_type = pointer_attr;
1345 }
1346 else
1347 pointer_type = RPC_FC_RP;
1348 }
1349 else /* pointers below other pointers default to unique */
1350 pointer_type = var_ptrs ? RPC_FC_UP : get_ptr_attr(type, RPC_FC_UP);
1351
1352 if (is_str && ptr_level + (var->array != NULL) == 1)
1353 return write_string_tfs(file, var->attrs, type, var->array, var->name, typeformat_offset);
1354
1355 if (is_array_type(var->attrs, ptr_level, var->array))
1356 return write_array_tfs(file, var->attrs, type, var->array, var->name, typeformat_offset);
1357
1358 if (ptr_level == 0)
1359 {
1360 /* basic types don't need a type format string */
1361 if (is_base_type(type->type))
1362 return 0;
1363
1364 switch (type->type)
1365 {
1366 case RPC_FC_STRUCT:
1367 case RPC_FC_PSTRUCT:
1368 case RPC_FC_CSTRUCT:
1369 case RPC_FC_CPSTRUCT:
1370 case RPC_FC_CVSTRUCT:
1371 case RPC_FC_BOGUS_STRUCT:
1372 return write_struct_tfs(file, type, var->name, typeformat_offset);
1373 case RPC_FC_ENCAPSULATED_UNION:
1374 case RPC_FC_NON_ENCAPSULATED_UNION:
1375 return write_union_tfs(file, var->attrs, type, var->name, typeformat_offset);
1376 case RPC_FC_IGNORE:
1377 case RPC_FC_BIND_PRIMITIVE:
1378 /* nothing to do */
1379 return 0;
1380 default:
1381 error("write_typeformatstring_var: Unsupported type 0x%x for variable %s\n", type->type, var->name);
1382 }
1383 }
1384 else if (ptr_level == 1)
1385 {
1386 size_t start_offset = *typeformat_offset;
1387 int in_attr = is_attr(var->attrs, ATTR_IN);
1388 int out_attr = is_attr(var->attrs, ATTR_OUT);
1389 const type_t *base = is_ptr(type) ? type->ref : type;
1390
1391 if (base->type == RPC_FC_IP)
1392 {
1393 return write_ip_tfs(file, base->attrs, base->name, typeformat_offset);
1394 }
1395
1396 /* special case for pointers to base types */
1397 switch (base->type)
1398 {
1399 #define CASE_BASETYPE(fctype) \
1400 case RPC_##fctype: \
1401 print_file(file, indent, "0x%x, 0x%x, /* %s %s[simple_pointer] */\n", \
1402 pointer_type, \
1403 (!in_attr && out_attr) ? 0x0C : 0x08, \
1404 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"), \
1405 (!in_attr && out_attr) ? "[allocated_on_stack] " : ""); \
1406 print_file(file, indent, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
1407 print_file(file, indent, "0x5c, /* FC_PAD */\n"); \
1408 *typeformat_offset += 4; \
1409 return start_offset
1410 CASE_BASETYPE(FC_BYTE);
1411 CASE_BASETYPE(FC_CHAR);
1412 CASE_BASETYPE(FC_SMALL);
1413 CASE_BASETYPE(FC_USMALL);
1414 CASE_BASETYPE(FC_WCHAR);
1415 CASE_BASETYPE(FC_SHORT);
1416 CASE_BASETYPE(FC_USHORT);
1417 CASE_BASETYPE(FC_LONG);
1418 CASE_BASETYPE(FC_ULONG);
1419 CASE_BASETYPE(FC_FLOAT);
1420 CASE_BASETYPE(FC_HYPER);
1421 CASE_BASETYPE(FC_DOUBLE);
1422 CASE_BASETYPE(FC_ENUM16);
1423 CASE_BASETYPE(FC_ENUM32);
1424 CASE_BASETYPE(FC_IGNORE);
1425 CASE_BASETYPE(FC_ERROR_STATUS_T);
1426 default:
1427 break;
1428 }
1429 }
1430
1431 assert(ptr_level > 0);
1432
1433 if (file)
1434 fprintf(file, "/* %2u */\n", *typeformat_offset);
1435 write_pointer_only_tfs(file, var->attrs, pointer_type,
1436 1 < ptr_level ? 0x10 : 0,
1437 2, typeformat_offset);
1438
1439 if (var_ptrs)
1440 --var_ptrs;
1441 else
1442 {
1443 --type_ptrs;
1444 type = type->ref;
1445 }
1446 }
1447 }
1448
1449
1450 void write_typeformatstring(FILE *file, const ifref_list_t *ifaces, int for_objects)
1451 {
1452 int indent = 0;
1453 const var_t *var;
1454 unsigned int typeformat_offset;
1455 const ifref_t *iface;
1456
1457 print_file(file, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
1458 print_file(file, indent, "{\n");
1459 indent++;
1460 print_file(file, indent, "0,\n");
1461 print_file(file, indent, "{\n");
1462 indent++;
1463 print_file(file, indent, "NdrFcShort(0x0),\n");
1464 typeformat_offset = 2;
1465
1466 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
1467 {
1468 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
1469 continue;
1470
1471 if (iface->iface->funcs)
1472 {
1473 const func_t *func;
1474 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
1475 {
1476 current_func = func;
1477 if (func->args)
1478 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
1479 write_typeformatstring_var(file, indent, var,
1480 &typeformat_offset);
1481 }
1482 }
1483 }
1484
1485 print_file(file, indent, "0x0\n");
1486 indent--;
1487 print_file(file, indent, "}\n");
1488 indent--;
1489 print_file(file, indent, "};\n");
1490 print_file(file, indent, "\n");
1491 }
1492
1493 static unsigned int get_required_buffer_size_type(
1494 const type_t *type, int ptr_level, const array_dims_t *array,
1495 const char *name, unsigned int *alignment)
1496 {
1497 *alignment = 0;
1498 if (ptr_level == 0 && !array)
1499 {
1500 switch (type->type)
1501 {
1502 case RPC_FC_BYTE:
1503 case RPC_FC_CHAR:
1504 case RPC_FC_USMALL:
1505 case RPC_FC_SMALL:
1506 *alignment = 4;
1507 return 1;
1508
1509 case RPC_FC_WCHAR:
1510 case RPC_FC_USHORT:
1511 case RPC_FC_SHORT:
1512 *alignment = 4;
1513 return 2;
1514
1515 case RPC_FC_ULONG:
1516 case RPC_FC_LONG:
1517 case RPC_FC_FLOAT:
1518 case RPC_FC_ERROR_STATUS_T:
1519 *alignment = 4;
1520 return 4;
1521
1522 case RPC_FC_HYPER:
1523 case RPC_FC_DOUBLE:
1524 *alignment = 8;
1525 return 8;
1526
1527 case RPC_FC_IGNORE:
1528 case RPC_FC_BIND_PRIMITIVE:
1529 return 0;
1530
1531 case RPC_FC_STRUCT:
1532 {
1533 size_t size = 0;
1534 const var_t *field;
1535 if (!type->fields) return 0;
1536 LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
1537 {
1538 unsigned int alignment;
1539 size += get_required_buffer_size_type(
1540 field->type, field->ptr_level, field->array, field->name,
1541 &alignment);
1542 }
1543 return size;
1544 }
1545
1546 default:
1547 error("get_required_buffer_size: Unknown/unsupported type: %s (0x%02x)\n", name, type->type);
1548 return 0;
1549 }
1550 }
1551 return 0;
1552 }
1553
1554 static unsigned int get_required_buffer_size(const var_t *var, unsigned int *alignment, enum pass pass)
1555 {
1556 expr_t *size_is = get_attrp(var->attrs, ATTR_SIZEIS);
1557 int has_size = (size_is && (size_is->type != EXPR_VOID));
1558 int in_attr = is_attr(var->attrs, ATTR_IN);
1559 int out_attr = is_attr(var->attrs, ATTR_OUT);
1560
1561 if (!in_attr && !out_attr)
1562 in_attr = 1;
1563
1564 *alignment = 0;
1565
1566 if (pass == PASS_OUT)
1567 {
1568 if (out_attr && var->ptr_level > 0)
1569 {
1570 type_t *type = var->type;
1571
1572 if (type->type == RPC_FC_STRUCT)
1573 {
1574 const var_t *field;
1575 unsigned int size = 36;
1576
1577 if (!type->fields) return size;
1578 LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
1579 {
1580 unsigned int align;
1581 size += get_required_buffer_size_type(
1582 field->type, field->ptr_level, field->array, field->name,
1583 &align);
1584 }
1585 return size;
1586 }
1587 }
1588 return 0;
1589 }
1590 else
1591 {
1592 if ((!out_attr || in_attr) && !has_size && !is_attr(var->attrs, ATTR_STRING) && !var->array)
1593 {
1594 if (var->ptr_level > 0)
1595 {
1596 type_t *type = var->type;
1597
1598 if (is_base_type(type->type))
1599 {
1600 return 25;
1601 }
1602 else if (type->type == RPC_FC_STRUCT)
1603 {
1604 unsigned int size = 36;
1605 const var_t *field;
1606
1607 if (!type->fields) return size;
1608 LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
1609 {
1610 unsigned int align;
1611 size += get_required_buffer_size_type(
1612 field->type, field->ptr_level, field->array, field->name,
1613 &align);
1614 }
1615 return size;
1616 }
1617 }
1618 }
1619
1620 return get_required_buffer_size_type(var->type, var->ptr_level, var->array, var->name, alignment);
1621 }
1622 }
1623
1624 static unsigned int get_function_buffer_size( const func_t *func, enum pass pass )
1625 {
1626 const var_t *var;
1627 unsigned int total_size = 0, alignment;
1628
1629 if (func->args)
1630 {
1631 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
1632 {
1633 total_size += get_required_buffer_size(var, &alignment, pass);
1634 total_size += alignment;
1635 }
1636 }
1637
1638 if (pass == PASS_OUT && !is_void(func->def->type, NULL))
1639 {
1640 total_size += get_required_buffer_size(func->def, &alignment, PASS_RETURN);
1641 total_size += alignment;
1642 }
1643 return total_size;
1644 }
1645
1646 static void print_phase_function(FILE *file, int indent, const char *type,
1647 enum remoting_phase phase,
1648 const char *varname, unsigned int type_offset)
1649 {
1650 const char *function;
1651 switch (phase)
1652 {
1653 case PHASE_BUFFERSIZE:
1654 function = "BufferSize";
1655 break;
1656 case PHASE_MARSHAL:
1657 function = "Marshall";
1658 break;
1659 case PHASE_UNMARSHAL:
1660 function = "Unmarshall";
1661 break;
1662 case PHASE_FREE:
1663 function = "Free";
1664 break;
1665 default:
1666 assert(0);
1667 return;
1668 }
1669
1670 print_file(file, indent, "Ndr%s%s(\n", type, function);
1671 indent++;
1672 print_file(file, indent, "&_StubMsg,\n");
1673 print_file(file, indent, "%s%s,\n",
1674 (phase == PHASE_UNMARSHAL) ? "(unsigned char **)&" : "(unsigned char *)",
1675 varname);
1676 print_file(file, indent, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n",
1677 type_offset, (phase == PHASE_UNMARSHAL) ? "," : ");");
1678 if (phase == PHASE_UNMARSHAL)
1679 print_file(file, indent, "0);\n");
1680 indent--;
1681 }
1682
1683 void print_phase_basetype(FILE *file, int indent, enum remoting_phase phase,
1684 enum pass pass, const var_t *var,
1685 const char *varname)
1686 {
1687 const type_t *type = var->type;
1688 unsigned int size;
1689 unsigned int alignment = 0;
1690 unsigned char rtype;
1691
1692 /* no work to do for other phases, buffer sizing is done elsewhere */
1693 if (phase != PHASE_MARSHAL && phase != PHASE_UNMARSHAL)
1694 return;
1695
1696 rtype = type->type;
1697
1698 switch (rtype)
1699 {
1700 case RPC_FC_BYTE:
1701 case RPC_FC_CHAR:
1702 case RPC_FC_SMALL:
1703 case RPC_FC_USMALL:
1704 size = 1;
1705 alignment = 1;
1706 break;
1707
1708 case RPC_FC_WCHAR:
1709 case RPC_FC_USHORT:
1710 case RPC_FC_SHORT:
1711 size = 2;
1712 alignment = 2;
1713 break;
1714
1715 case RPC_FC_ULONG:
1716 case RPC_FC_LONG:
1717 case RPC_FC_FLOAT:
1718 case RPC_FC_ERROR_STATUS_T:
1719 size = 4;
1720 alignment = 4;
1721 break;
1722
1723 case RPC_FC_HYPER:
1724 case RPC_FC_DOUBLE:
1725 size = 8;
1726 alignment = 8;
1727 break;
1728
1729 case RPC_FC_IGNORE:
1730 case RPC_FC_BIND_PRIMITIVE:
1731 /* no marshalling needed */
1732 return;
1733
1734 default:
1735 error("print_phase_basetype: Unsupported type: %s (0x%02x, ptr_level: 0)\n", var->name, rtype);
1736 size = 0;
1737 }
1738
1739 print_file(file, indent, "_StubMsg.Buffer = (unsigned char *)(((long)_StubMsg.Buffer + %u) & ~0x%x);\n",
1740 alignment - 1, alignment - 1);
1741
1742 if (phase == PHASE_MARSHAL)
1743 {
1744 print_file(file, indent, "*(");
1745 write_type(file, var->type, NULL, var->tname);
1746 if (var->ptr_level)
1747 fprintf(file, " *)_StubMsg.Buffer = *");
1748 else
1749 fprintf(file, " *)_StubMsg.Buffer = ");
1750 fprintf(file, varname);
1751 fprintf(file, ";\n");
1752 }
1753 else if (phase == PHASE_UNMARSHAL)
1754 {
1755 if (pass == PASS_IN || pass == PASS_RETURN)
1756 print_file(file, indent, "");
1757 else
1758 print_file(file, indent, "*");
1759 fprintf(file, varname);
1760 if (pass == PASS_IN && var->ptr_level)
1761 fprintf(file, " = (");
1762 else
1763 fprintf(file, " = *(");
1764 write_type(file, var->type, NULL, var->tname);
1765 fprintf(file, " *)_StubMsg.Buffer;\n");
1766 }
1767
1768 print_file(file, indent, "_StubMsg.Buffer += sizeof(");
1769 write_type(file, var->type, NULL, var->tname);
1770 fprintf(file, ");\n");
1771 }
1772
1773 /* returns whether the MaxCount, Offset or ActualCount members need to be
1774 * filled in for the specified phase */
1775 static inline int is_size_needed_for_phase(enum remoting_phase phase)
1776 {
1777 return (phase != PHASE_UNMARSHAL);
1778 }
1779
1780 void write_remoting_arguments(FILE *file, int indent, const func_t *func,
1781 unsigned int *type_offset, enum pass pass,
1782 enum remoting_phase phase)
1783 {
1784 const expr_t *length_is;
1785 const expr_t *size_is;
1786 int in_attr, out_attr, has_length, has_size, pointer_type;
1787 const var_t *var;
1788
1789 if (!func->args)
1790 return;
1791
1792 if (phase == PHASE_BUFFERSIZE)
1793 {
1794 unsigned int size = get_function_buffer_size( func, pass );
1795 print_file(file, indent, "_StubMsg.BufferLength = %u;\n", size);
1796 }
1797
1798 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
1799 {
1800 const type_t *type = var->type;
1801 unsigned char rtype;
1802
1803 length_is = get_attrp(var->attrs, ATTR_LENGTHIS);
1804 size_is = get_attrp(var->attrs, ATTR_SIZEIS);
1805 has_length = length_is && (length_is->type != EXPR_VOID);
1806 has_size = (size_is && (size_is->type != EXPR_VOID)) || (var->array && is_conformant_array(var->array));
1807
1808 pointer_type = get_attrv(var->attrs, ATTR_POINTERTYPE);
1809 if (!pointer_type)
1810 pointer_type = RPC_FC_RP;
1811
1812 in_attr = is_attr(var->attrs, ATTR_IN);
1813 out_attr = is_attr(var->attrs, ATTR_OUT);
1814 if (!in_attr && !out_attr)
1815 in_attr = 1;
1816
1817 switch (pass)
1818 {
1819 case PASS_IN:
1820 if (!in_attr) goto next;
1821 break;
1822 case PASS_OUT:
1823 if (!out_attr) goto next;
1824 break;
1825 case PASS_RETURN:
1826 break;
1827 }
1828
1829 rtype = type->type;
1830
1831 if (is_string_type(var->attrs, var->ptr_level, var->array))
1832 {
1833 if (var->array && !is_conformant_array(var->array))
1834 print_phase_function(file, indent, "NonConformantString", phase, var->name, *type_offset);
1835 else
1836 {
1837 if (size_is && is_size_needed_for_phase(phase))
1838 {
1839 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
1840 write_expr(file, size_is, 1);
1841 fprintf(file, ";\n");
1842 }
1843
1844 if ((phase == PHASE_FREE) || (pointer_type == RPC_FC_UP))
1845 print_phase_function(file, indent, "Pointer", phase, var->name, *type_offset);
1846 else
1847 print_phase_function(file, indent, "ConformantString", phase, var->name,
1848 *type_offset + (has_size ? 4 : 2));
1849 }
1850 }
1851 else if (is_array_type(var->attrs, var->ptr_level, var->array))
1852 {
1853 const char *array_type;
1854
1855 if (var->array && list_count(var->array) > 1) /* multi-dimensional array */
1856 array_type = "ComplexArray";
1857 else
1858 {
1859 const expr_t *dim = LIST_ENTRY( list_head( var->array ), expr_t, entry );
1860 if (!has_length && !has_size)
1861 array_type = "FixedArray";
1862 else if (has_length && !has_size)
1863 {
1864 if (is_size_needed_for_phase(phase))
1865 {
1866 print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1867 print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
1868 write_expr(file, length_is, 1);
1869 fprintf(file, ";\n\n");
1870 }
1871 array_type = "VaryingArray";
1872 }
1873 else if (!has_length && has_size)
1874 {
1875 if (is_size_needed_for_phase(phase) && phase != PHASE_FREE)
1876 {
1877 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
1878 write_expr(file, size_is ? size_is : dim, 1);
1879 fprintf(file, ";\n\n");
1880 }
1881 array_type = "ConformantArray";
1882 }
1883 else
1884 {
1885 if (is_size_needed_for_phase(phase))
1886 {
1887 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
1888 write_expr(file, size_is ? size_is : dim, 1);
1889 fprintf(file, ";\n");
1890 print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
1891 print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
1892 write_expr(file, length_is, 1);
1893 fprintf(file, ";\n\n");
1894 }
1895 array_type = "ConformantVaryingArray";
1896 }
1897 }
1898
1899 if (!in_attr && phase == PHASE_FREE)
1900 {
1901 print_file(file, indent, "if (%s)\n", var->name);
1902 indent++;
1903 print_file(file, indent, "_StubMsg.pfnFree(%s);\n", var->name);
1904 }
1905 else if (phase != PHASE_FREE)
1906 {
1907 if (pointer_type == RPC_FC_UP)
1908 print_phase_function(file, indent, "Pointer", phase, var->name, *type_offset);
1909 else
1910 print_phase_function(file, indent, array_type, phase, var->name, *type_offset + 4);
1911 }
1912 }
1913 else if (var->ptr_level == 0 && is_base_type(rtype))
1914 {
1915 print_phase_basetype(file, indent, phase, pass, var, var->name);
1916 }
1917 else if (var->ptr_level == 0)
1918 {
1919 const char *ndrtype;
1920
1921 switch (rtype)
1922 {
1923 case RPC_FC_STRUCT:
1924 ndrtype = "SimpleStruct";
1925 break;
1926 case RPC_FC_CSTRUCT:
1927 case RPC_FC_CPSTRUCT:
1928 ndrtype = "ConformantStruct";
1929 break;
1930 case RPC_FC_CVSTRUCT:
1931 ndrtype = "ConformantVaryingStruct";
1932 break;
1933 case RPC_FC_BOGUS_STRUCT:
1934 ndrtype = "ComplexStruct";
1935 break;
1936 default:
1937 error("write_remoting_arguments: Unsupported type: %s (0x%02x, ptr_level: %d)\n",
1938 var->name, rtype, var->ptr_level);
1939 ndrtype = NULL;
1940 }
1941
1942 print_phase_function(file, indent, ndrtype, phase, var->name, *type_offset);
1943 }
1944 else
1945 {
1946 if ((var->ptr_level == 1) && (pointer_type == RPC_FC_RP) && is_base_type(rtype))
1947 {
1948 print_phase_basetype(file, indent, phase, pass, var, var->name);
1949 }
1950 else if ((var->ptr_level == 1) && (pointer_type == RPC_FC_RP) && (rtype == RPC_FC_STRUCT))
1951 {
1952 if (phase != PHASE_BUFFERSIZE && phase != PHASE_FREE)
1953 print_phase_function(file, indent, "SimpleStruct", phase, var->name, *type_offset + 4);
1954 }
1955 else
1956 {
1957 print_phase_function(file, indent, "Pointer", phase, var->name, *type_offset);
1958 }
1959 }
1960 fprintf(file, "\n");
1961 next:
1962 *type_offset += get_size_typeformatstring_var(var);
1963 }
1964 }
1965
1966
1967 size_t get_size_procformatstring_var(const var_t *var)
1968 {
1969 unsigned int type_offset = 2;
1970 return write_procformatstring_var(NULL, 0, var, FALSE, &type_offset);
1971 }
1972
1973
1974 size_t get_size_typeformatstring_var(const var_t *var)
1975 {
1976 unsigned int type_offset = 0;
1977 write_typeformatstring_var(NULL, 0, var, &type_offset);
1978 return type_offset;
1979 }
1980
1981 size_t get_size_procformatstring(const ifref_list_t *ifaces, int for_objects)
1982 {
1983 const ifref_t *iface;
1984 size_t size = 1;
1985 const func_t *func;
1986 const var_t *var;
1987
1988 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
1989 {
1990 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
1991 continue;
1992
1993 if (iface->iface->funcs)
1994 {
1995 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
1996 {
1997 /* argument list size */
1998 if (func->args)
1999 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2000 size += get_size_procformatstring_var(var);
2001
2002 var = func->def;
2003 /* return value size */
2004 if (is_void(var->type, NULL))
2005 size += 2;
2006 else
2007 size += get_size_procformatstring_var(var);
2008 }
2009 }
2010 }
2011 return size;
2012 }
2013
2014 size_t get_size_typeformatstring(const ifref_list_t *ifaces, int for_objects)
2015 {
2016 const ifref_t *iface;
2017 size_t size = 3;
2018 const func_t *func;
2019 const var_t *var;
2020
2021 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
2022 {
2023 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
2024 continue;
2025
2026 if (iface->iface->funcs)
2027 {
2028 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
2029 {
2030 /* argument list size */
2031 if (func->args)
2032 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2033 size += get_size_typeformatstring_var(var);
2034 }
2035 }
2036 }
2037 return size;
2038 }
2039
2040 static void write_struct_expr(FILE *h, const expr_t *e, int brackets,
2041 const var_list_t *fields, const char *structvar)
2042 {
2043 switch (e->type) {
2044 case EXPR_VOID:
2045 break;
2046 case EXPR_NUM:
2047 fprintf(h, "%ld", e->u.lval);
2048 break;
2049 case EXPR_HEXNUM:
2050 fprintf(h, "0x%lx", e->u.lval);
2051 break;
2052 case EXPR_TRUEFALSE:
2053 if (e->u.lval == 0)
2054 fprintf(h, "FALSE");
2055 else
2056 fprintf(h, "TRUE");
2057 break;
2058 case EXPR_IDENTIFIER:
2059 {
2060 const var_t *field;
2061 LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
2062 if (!strcmp(e->u.sval, field->name))
2063 {
2064 fprintf(h, "%s->%s", structvar, e->u.sval);
2065 break;
2066 }
2067
2068 if (&field->entry == fields) error("no field found for identifier %s\n", e->u.sval);
2069 break;
2070 }
2071 case EXPR_NEG:
2072 fprintf(h, "-");
2073 write_struct_expr(h, e->ref, 1, fields, structvar);
2074 break;
2075 case EXPR_NOT:
2076 fprintf(h, "~");
2077 write_struct_expr(h, e->ref, 1, fields, structvar);
2078 break;
2079 case EXPR_PPTR:
2080 fprintf(h, "*");
2081 write_struct_expr(h, e->ref, 1, fields, structvar);
2082 break;
2083 case EXPR_CAST:
2084 fprintf(h, "(");
2085 write_type(h, e->u.tref->ref, NULL, e->u.tref->name);
2086 fprintf(h, ")");
2087 write_struct_expr(h, e->ref, 1, fields, structvar);
2088 break;
2089 case EXPR_SIZEOF:
2090 fprintf(h, "sizeof(");
2091 write_type(h, e->u.tref->ref, NULL, e->u.tref->name);
2092 fprintf(h, ")");
2093 break;
2094 case EXPR_SHL:
2095 case EXPR_SHR:
2096 case EXPR_MUL:
2097 case EXPR_DIV:
2098 case EXPR_ADD:
2099 case EXPR_SUB:
2100 case EXPR_AND:
2101 case EXPR_OR:
2102 if (brackets) fprintf(h, "(");
2103 write_struct_expr(h, e->ref, 1, fields, structvar);
2104 switch (e->type) {
2105 case EXPR_SHL: fprintf(h, " << "); break;
2106 case EXPR_SHR: fprintf(h, " >> "); break;
2107 case EXPR_MUL: fprintf(h, " * "); break;
2108 case EXPR_DIV: fprintf(h, " / "); break;
2109 case EXPR_ADD: fprintf(h, " + "); break;
2110 case EXPR_SUB: fprintf(h, " - "); break;
2111 case EXPR_AND: fprintf(h, " & "); break;
2112 case EXPR_OR: fprintf(h, " | "); break;
2113 default: break;
2114 }
2115 write_struct_expr(h, e->u.ext, 1, fields, structvar);
2116 if (brackets) fprintf(h, ")");
2117 break;
2118 case EXPR_COND:
2119 if (brackets) fprintf(h, "(");
2120 write_struct_expr(h, e->ref, 1, fields, structvar);
2121 fprintf(h, " ? ");
2122 write_struct_expr(h, e->u.ext, 1, fields, structvar);
2123 fprintf(h, " : ");
2124 write_struct_expr(h, e->ext2, 1, fields, structvar);
2125 if (brackets) fprintf(h, ")");
2126 break;
2127 }
2128 }
2129
2130
2131 void declare_stub_args( FILE *file, int indent, const func_t *func )
2132 {
2133 int in_attr, out_attr;
2134 int i = 0;
2135 const var_t *def = func->def;
2136 const var_t *var;
2137
2138 /* declare return value '_RetVal' */
2139 if (!is_void(def->type, NULL))
2140 {
2141 print_file(file, indent, "");
2142 write_type(file, def->type, def, def->tname);
2143 fprintf(file, " _RetVal;\n");
2144 }
2145
2146 if (!func->args)
2147 return;
2148
2149 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2150 {
2151 const expr_t *size_is = get_attrp(var->attrs, ATTR_SIZEIS);
2152 int has_size = size_is && (size_is->type != EXPR_VOID);
2153 int is_string = is_attr(var->attrs, ATTR_STRING);
2154
2155 in_attr = is_attr(var->attrs, ATTR_IN);
2156 out_attr = is_attr(var->attrs, ATTR_OUT);
2157 if (!out_attr && !in_attr)
2158 in_attr = 1;
2159
2160 if (!in_attr && !has_size && !is_string)
2161 {
2162 int indirection;
2163 print_file(file, indent, "");
2164 write_type(file, var->type, NULL, var->tname);
2165 for (indirection = 0; indirection < var->ptr_level - 1; indirection++)
2166 fprintf(file, "*");
2167 fprintf(file, " _W%u;\n", i++);
2168 }
2169
2170 print_file(file, indent, "");
2171 write_type(file, var->type, var, var->tname);
2172 fprintf(file, " ");
2173 write_name(file, var);
2174 write_array(file, var->array, 0);
2175 fprintf(file, ";\n");
2176 }
2177 }
2178
2179
2180 void assign_stub_out_args( FILE *file, int indent, const func_t *func )
2181 {
2182 int in_attr, out_attr;
2183 int i = 0, sep = 0;
2184 const var_t *var;
2185 const expr_t *size_is;
2186 int has_size;
2187
2188 if (!func->args)
2189 return;
2190
2191 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2192 {
2193 int is_string = is_attr(var->attrs, ATTR_STRING);
2194 size_is = get_attrp(var->attrs, ATTR_SIZEIS);
2195 has_size = size_is && (size_is->type != EXPR_VOID);
2196 in_attr = is_attr(var->attrs, ATTR_IN);
2197 out_attr = is_attr(var->attrs, ATTR_OUT);
2198 if (!out_attr && !in_attr)
2199 in_attr = 1;
2200
2201 if (!in_attr)
2202 {
2203 print_file(file, indent, "");
2204 write_name(file, var);
2205
2206 if (has_size)
2207 {
2208 unsigned int size;
2209 type_t *type = var->type;
2210
2211 fprintf(file, " = NdrAllocate(&_StubMsg, ");
2212 write_expr(file, size_is, 1);
2213 size = get_type_memsize(type);
2214 fprintf(file, " * %u);\n", size);
2215 }
2216 else if (!is_string)
2217 {
2218 fprintf(file, " = &_W%u;\n", i);
2219 if (var->ptr_level > 1)
2220 print_file(file, indent, "_W%u = 0;\n", i);
2221 i++;
2222 }
2223
2224 sep = 1;
2225 }
2226 }
2227 if (sep)
2228 fprintf(file, "\n");
2229 }
2230
2231
2232 int write_expr_eval_routines(FILE *file, const char *iface)
2233 {
2234 int result = 0;
2235 struct expr_eval_routine *eval;
2236 unsigned short callback_offset = 0;
2237
2238 LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
2239 {
2240 int indent = 0;
2241 result = 1;
2242 print_file(file, indent, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
2243 iface, eval->structure->name, callback_offset);
2244 print_file(file, indent, "{\n");
2245 indent++;
2246 print_file(file, indent, "struct %s *" STRUCT_EXPR_EVAL_VAR " = (struct %s *)(pStubMsg->StackTop - %u);\n",
2247 eval->structure->name, eval->structure->name, eval->structure_size);
2248 fprintf(file, "\n");
2249 print_file(file, indent, "pStubMsg->Offset = 0;\n"); /* FIXME */
2250 print_file(file, indent, "pStubMsg->MaxCount = (unsigned long)");
2251 write_struct_expr(file, eval->expr, 1, eval->structure->fields, STRUCT_EXPR_EVAL_VAR);
2252 fprintf(file, ";\n");
2253 indent--;
2254 print_file(file, indent, "}\n\n");
2255 callback_offset++;
2256 }
2257 return result;
2258 }
2259
2260 void write_expr_eval_routine_list(FILE *file, const char *iface)
2261 {
2262 struct expr_eval_routine *eval;
2263 struct expr_eval_routine *cursor;
2264 unsigned short callback_offset = 0;
2265
2266 fprintf(file, "static const EXPR_EVAL ExprEvalRoutines[] =\n");
2267 fprintf(file, "{\n");
2268
2269 LIST_FOR_EACH_ENTRY_SAFE(eval, cursor, &expr_eval_routines, struct expr_eval_routine, entry)
2270 {
2271 print_file(file, 1, "%s_%sExprEval_%04u,\n",
2272 iface, eval->structure->name, callback_offset);
2273
2274 callback_offset++;
2275 list_remove(&eval->entry);
2276 free(eval);
2277 }
2278
2279 fprintf(file, "};\n\n");
2280 }
Maarten's multimedia branch