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