?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
widl: Added support for floating-point constants.
[wine/multimedia.git] / tools / widl / typegen.c
blob73a36224bd620d5604359b26710b76c7385ac02b
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 fields_memsize(const var_list_t *fields, unsigned int *align);
63 static size_t write_struct_tfs(FILE *file, type_t *type, const char *name, unsigned int *tfsoff);
64 static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
65 const char *name, int write_ptr, unsigned int *tfsoff);
66
67 const char *string_of_type(unsigned char type)
68 {
69 switch (type)
70 {
71 case RPC_FC_BYTE: return "FC_BYTE";
72 case RPC_FC_CHAR: return "FC_CHAR";
73 case RPC_FC_SMALL: return "FC_SMALL";
74 case RPC_FC_USMALL: return "FC_USMALL";
75 case RPC_FC_WCHAR: return "FC_WCHAR";
76 case RPC_FC_SHORT: return "FC_SHORT";
77 case RPC_FC_USHORT: return "FC_USHORT";
78 case RPC_FC_LONG: return "FC_LONG";
79 case RPC_FC_ULONG: return "FC_ULONG";
80 case RPC_FC_FLOAT: return "FC_FLOAT";
81 case RPC_FC_HYPER: return "FC_HYPER";
82 case RPC_FC_DOUBLE: return "FC_DOUBLE";
83 case RPC_FC_ENUM16: return "FC_ENUM16";
84 case RPC_FC_ENUM32: return "FC_ENUM32";
85 case RPC_FC_IGNORE: return "FC_IGNORE";
86 case RPC_FC_ERROR_STATUS_T: return "FC_ERROR_STATUS_T";
87 case RPC_FC_RP: return "FC_RP";
88 case RPC_FC_UP: return "FC_UP";
89 case RPC_FC_OP: return "FC_OP";
90 case RPC_FC_FP: return "FC_FP";
91 case RPC_FC_ENCAPSULATED_UNION: return "FC_ENCAPSULATED_UNION";
92 case RPC_FC_NON_ENCAPSULATED_UNION: return "FC_NON_ENCAPSULATED_UNION";
93 case RPC_FC_STRUCT: return "FC_STRUCT";
94 case RPC_FC_PSTRUCT: return "FC_PSTRUCT";
95 case RPC_FC_CSTRUCT: return "FC_CSTRUCT";
96 case RPC_FC_CPSTRUCT: return "FC_CPSTRUCT";
97 case RPC_FC_CVSTRUCT: return "FC_CVSTRUCT";
98 case RPC_FC_BOGUS_STRUCT: return "FC_BOGUS_STRUCT";
99 case RPC_FC_SMFARRAY: return "FC_SMFARRAY";
100 case RPC_FC_LGFARRAY: return "FC_LGFARRAY";
101 case RPC_FC_SMVARRAY: return "FC_SMVARRAY";
102 case RPC_FC_LGVARRAY: return "FC_LGVARRAY";
103 case RPC_FC_CARRAY: return "FC_CARRAY";
104 case RPC_FC_CVARRAY: return "FC_CVARRAY";
105 case RPC_FC_BOGUS_ARRAY: return "FC_BOGUS_ARRAY";
106 default:
107 error("string_of_type: unknown type 0x%02x\n", type);
108 return NULL;
109 }
110 }
111
112 int is_struct(unsigned char type)
113 {
114 switch (type)
115 {
116 case RPC_FC_STRUCT:
117 case RPC_FC_PSTRUCT:
118 case RPC_FC_CSTRUCT:
119 case RPC_FC_CPSTRUCT:
120 case RPC_FC_CVSTRUCT:
121 case RPC_FC_BOGUS_STRUCT:
122 return 1;
123 default:
124 return 0;
125 }
126 }
127
128 static int is_non_complex_struct(const type_t *type)
129 {
130 switch (type->type)
131 {
132 case RPC_FC_STRUCT:
133 case RPC_FC_PSTRUCT:
134 case RPC_FC_CSTRUCT:
135 case RPC_FC_CPSTRUCT:
136 case RPC_FC_CVSTRUCT:
137 return 1;
138 default:
139 return 0;
140 }
141 }
142
143 int is_union(unsigned char type)
144 {
145 switch (type)
146 {
147 case RPC_FC_ENCAPSULATED_UNION:
148 case RPC_FC_NON_ENCAPSULATED_UNION:
149 return 1;
150 default:
151 return 0;
152 }
153 }
154
155 static unsigned short user_type_offset(const char *name)
156 {
157 user_type_t *ut;
158 unsigned short off = 0;
159 LIST_FOR_EACH_ENTRY(ut, &user_type_list, user_type_t, entry)
160 {
161 if (strcmp(name, ut->name) == 0)
162 return off;
163 ++off;
164 }
165 error("user_type_offset: couldn't find type (%s)\n", name);
166 return 0;
167 }
168
169 static void update_tfsoff(type_t *type, unsigned int offset, FILE *file)
170 {
171 type->typestring_offset = offset;
172 if (file) type->tfswrite = FALSE;
173 }
174
175 static void guard_rec(type_t *type)
176 {
177 /* types that contain references to themselves (like a linked list),
178 need to be shielded from infinite recursion when writing embedded
179 types */
180 if (type->typestring_offset)
181 type->tfswrite = FALSE;
182 else
183 type->typestring_offset = 1;
184 }
185
186 static type_t *get_user_type(const type_t *t, const char **pname)
187 {
188 for (;;)
189 {
190 type_t *ut = get_attrp(t->attrs, ATTR_WIREMARSHAL);
191 if (ut)
192 {
193 if (pname)
194 *pname = t->name;
195 return ut;
196 }
197
198 if (t->kind == TKIND_ALIAS)
199 t = t->orig;
200 else
201 return 0;
202 }
203 }
204
205 static int is_user_type(const type_t *t)
206 {
207 return get_user_type(t, NULL) != NULL;
208 }
209
210 static int is_embedded_complex(const type_t *type)
211 {
212 unsigned char tc = type->type;
213 return is_struct(tc) || is_union(tc) || is_array(type) || is_user_type(type)
214 || (is_ptr(type) && type->ref->type == RPC_FC_IP);
215 }
216
217 static int compare_expr(const expr_t *a, const expr_t *b)
218 {
219 int ret;
220
221 if (a->type != b->type)
222 return a->type - b->type;
223
224 switch (a->type)
225 {
226 case EXPR_NUM:
227 case EXPR_HEXNUM:
228 case EXPR_TRUEFALSE:
229 return a->u.lval - b->u.lval;
230 case EXPR_DOUBLE:
231 return a->u.dval - b->u.dval;
232 case EXPR_IDENTIFIER:
233 return strcmp(a->u.sval, b->u.sval);
234 case EXPR_COND:
235 ret = compare_expr(a->ref, b->ref);
236 if (ret != 0)
237 return ret;
238 ret = compare_expr(a->u.ext, b->u.ext);
239 if (ret != 0)
240 return ret;
241 return compare_expr(a->ext2, b->ext2);
242 case EXPR_OR:
243 case EXPR_AND:
244 case EXPR_ADD:
245 case EXPR_SUB:
246 case EXPR_MUL:
247 case EXPR_DIV:
248 case EXPR_SHL:
249 case EXPR_SHR:
250 ret = compare_expr(a->ref, b->ref);
251 if (ret != 0)
252 return ret;
253 return compare_expr(a->u.ext, b->u.ext);
254 case EXPR_NOT:
255 case EXPR_NEG:
256 case EXPR_PPTR:
257 case EXPR_CAST:
258 case EXPR_SIZEOF:
259 return compare_expr(a->ref, b->ref);
260 case EXPR_VOID:
261 return 0;
262 }
263 return -1;
264 }
265
266 #define WRITE_FCTYPE(file, fctype, typestring_offset) \
267 do { \
268 if (file) \
269 fprintf(file, "/* %2u */\n", typestring_offset); \
270 print_file((file), 2, "0x%02x, /* " #fctype " */\n", RPC_##fctype); \
271 } \
272 while (0)
273
274 static void print_file(FILE *file, int indent, const char *format, ...)
275 {
276 va_list va;
277 va_start(va, format);
278 print(file, indent, format, va);
279 va_end(va);
280 }
281
282 void print(FILE *file, int indent, const char *format, va_list va)
283 {
284 if (file)
285 {
286 if (format[0] != '\n')
287 while (0 < indent--)
288 fprintf(file, " ");
289 vfprintf(file, format, va);
290 }
291 }
292
293 void write_parameters_init(FILE *file, int indent, const func_t *func)
294 {
295 const var_t *var;
296
297 if (!func->args)
298 return;
299
300 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
301 {
302 const type_t *t = var->type;
303 const char *n = var->name;
304 if (decl_indirect(t))
305 print_file(file, indent, "MIDL_memset(&%s, 0, sizeof %s);\n", n, n);
306 else if (is_ptr(t) || is_array(t))
307 print_file(file, indent, "%s = 0;\n", n);
308 }
309
310 fprintf(file, "\n");
311 }
312
313 static void write_formatdesc(FILE *f, int indent, const char *str)
314 {
315 print_file(f, indent, "typedef struct _MIDL_%s_FORMAT_STRING\n", str);
316 print_file(f, indent, "{\n");
317 print_file(f, indent + 1, "short Pad;\n");
318 print_file(f, indent + 1, "unsigned char Format[%s_FORMAT_STRING_SIZE];\n", str);
319 print_file(f, indent, "} MIDL_%s_FORMAT_STRING;\n", str);
320 print_file(f, indent, "\n");
321 }
322
323 void write_formatstringsdecl(FILE *f, int indent, ifref_list_t *ifaces, int for_objects)
324 {
325 print_file(f, indent, "#define TYPE_FORMAT_STRING_SIZE %d\n",
326 get_size_typeformatstring(ifaces, for_objects));
327
328 print_file(f, indent, "#define PROC_FORMAT_STRING_SIZE %d\n",
329 get_size_procformatstring(ifaces, for_objects));
330
331 fprintf(f, "\n");
332 write_formatdesc(f, indent, "TYPE");
333 write_formatdesc(f, indent, "PROC");
334 fprintf(f, "\n");
335 print_file(f, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;\n");
336 print_file(f, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;\n");
337 print_file(f, indent, "\n");
338 }
339
340 static inline int is_base_type(unsigned char type)
341 {
342 switch (type)
343 {
344 case RPC_FC_BYTE:
345 case RPC_FC_CHAR:
346 case RPC_FC_USMALL:
347 case RPC_FC_SMALL:
348 case RPC_FC_WCHAR:
349 case RPC_FC_USHORT:
350 case RPC_FC_SHORT:
351 case RPC_FC_ULONG:
352 case RPC_FC_LONG:
353 case RPC_FC_HYPER:
354 case RPC_FC_IGNORE:
355 case RPC_FC_FLOAT:
356 case RPC_FC_DOUBLE:
357 case RPC_FC_ENUM16:
358 case RPC_FC_ENUM32:
359 case RPC_FC_ERROR_STATUS_T:
360 case RPC_FC_BIND_PRIMITIVE:
361 return TRUE;
362
363 default:
364 return FALSE;
365 }
366 }
367
368 int decl_indirect(const type_t *t)
369 {
370 return is_user_type(t)
371 || (!is_base_type(t->type)
372 && !is_ptr(t)
373 && !is_array(t));
374 }
375
376 static size_t write_procformatstring_var(FILE *file, int indent,
377 const var_t *var, int is_return)
378 {
379 size_t size;
380 const type_t *type = var->type;
381
382 int is_in = is_attr(var->attrs, ATTR_IN);
383 int is_out = is_attr(var->attrs, ATTR_OUT);
384
385 if (!is_in && !is_out) is_in = TRUE;
386
387 if (!type->declarray && is_base_type(type->type))
388 {
389 if (is_return)
390 print_file(file, indent, "0x53, /* FC_RETURN_PARAM_BASETYPE */\n");
391 else
392 print_file(file, indent, "0x4e, /* FC_IN_PARAM_BASETYPE */\n");
393
394 if (type->type == RPC_FC_BIND_PRIMITIVE)
395 {
396 print_file(file, indent, "0x%02x, /* FC_IGNORE */\n", RPC_FC_IGNORE);
397 size = 2; /* includes param type prefix */
398 }
399 else if (is_base_type(type->type))
400 {
401 print_file(file, indent, "0x%02x, /* %s */\n", type->type, string_of_type(type->type));
402 size = 2; /* includes param type prefix */
403 }
404 else
405 {
406 error("Unknown/unsupported type: %s (0x%02x)\n", var->name, type->type);
407 size = 0;
408 }
409 }
410 else
411 {
412 if (is_return)
413 print_file(file, indent, "0x52, /* FC_RETURN_PARAM */\n");
414 else if (is_in && is_out)
415 print_file(file, indent, "0x50, /* FC_IN_OUT_PARAM */\n");
416 else if (is_out)
417 print_file(file, indent, "0x51, /* FC_OUT_PARAM */\n");
418 else
419 print_file(file, indent, "0x4d, /* FC_IN_PARAM */\n");
420
421 print_file(file, indent, "0x01,\n");
422 print_file(file, indent, "NdrFcShort(0x%x),\n", type->typestring_offset);
423 size = 4; /* includes param type prefix */
424 }
425 return size;
426 }
427
428 void write_procformatstring(FILE *file, const ifref_list_t *ifaces, int for_objects)
429 {
430 const ifref_t *iface;
431 int indent = 0;
432 const var_t *var;
433
434 print_file(file, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
435 print_file(file, indent, "{\n");
436 indent++;
437 print_file(file, indent, "0,\n");
438 print_file(file, indent, "{\n");
439 indent++;
440
441 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
442 {
443 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
444 continue;
445
446 if (iface->iface->funcs)
447 {
448 const func_t *func;
449 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
450 {
451 if (is_local(func->def->attrs)) continue;
452 /* emit argument data */
453 if (func->args)
454 {
455 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
456 write_procformatstring_var(file, indent, var, FALSE);
457 }
458
459 /* emit return value data */
460 var = func->def;
461 if (is_void(var->type))
462 {
463 print_file(file, indent, "0x5b, /* FC_END */\n");
464 print_file(file, indent, "0x5c, /* FC_PAD */\n");
465 }
466 else
467 write_procformatstring_var(file, indent, var, TRUE);
468 }
469 }
470 }
471
472 print_file(file, indent, "0x0\n");
473 indent--;
474 print_file(file, indent, "}\n");
475 indent--;
476 print_file(file, indent, "};\n");
477 print_file(file, indent, "\n");
478 }
479
480 static int write_base_type(FILE *file, const type_t *type, unsigned int *typestring_offset)
481 {
482 if (is_base_type(type->type))
483 {
484 print_file(file, 2, "0x%02x,\t/* %s */\n", type->type, string_of_type(type->type));
485 *typestring_offset += 1;
486 return 1;
487 }
488
489 return 0;
490 }
491
492 /* write conformance / variance descriptor */
493 static size_t write_conf_or_var_desc(FILE *file, const func_t *func, const type_t *structure,
494 unsigned int baseoff, const expr_t *expr)
495 {
496 unsigned char operator_type = 0;
497 const char *operator_string = "no operators";
498 const expr_t *subexpr;
499 unsigned char correlation_type;
500
501 if (!file) return 4; /* optimisation for sizing pass */
502
503 if (expr->is_const)
504 {
505 if (expr->cval > UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX)
506 error("write_conf_or_var_desc: constant value %ld is greater than "
507 "the maximum constant size of %d\n", expr->cval,
508 UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX);
509
510 print_file(file, 2, "0x%x, /* Corr desc: constant, val = %ld */\n",
511 RPC_FC_CONSTANT_CONFORMANCE, expr->cval);
512 print_file(file, 2, "0x%x,\n", expr->cval & ~USHRT_MAX);
513 print_file(file, 2, "NdrFcShort(0x%x),\n", expr->cval & USHRT_MAX);
514
515 return 4;
516 }
517
518 subexpr = expr;
519 switch (subexpr->type)
520 {
521 case EXPR_PPTR:
522 subexpr = subexpr->ref;
523 operator_type = RPC_FC_DEREFERENCE;
524 operator_string = "FC_DEREFERENCE";
525 break;
526 case EXPR_DIV:
527 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
528 {
529 subexpr = subexpr->ref;
530 operator_type = RPC_FC_DIV_2;
531 operator_string = "FC_DIV_2";
532 }
533 break;
534 case EXPR_MUL:
535 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
536 {
537 subexpr = subexpr->ref;
538 operator_type = RPC_FC_MULT_2;
539 operator_string = "FC_MULT_2";
540 }
541 break;
542 case EXPR_SUB:
543 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
544 {
545 subexpr = subexpr->ref;
546 operator_type = RPC_FC_SUB_1;
547 operator_string = "FC_SUB_1";
548 }
549 break;
550 case EXPR_ADD:
551 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
552 {
553 subexpr = subexpr->ref;
554 operator_type = RPC_FC_ADD_1;
555 operator_string = "FC_ADD_1";
556 }
557 break;
558 default:
559 break;
560 }
561
562 if (subexpr->type == EXPR_IDENTIFIER)
563 {
564 const type_t *correlation_variable = NULL;
565 unsigned char correlation_variable_type;
566 unsigned char param_type = 0;
567 const char *param_type_string = NULL;
568 size_t offset;
569
570 if (structure)
571 {
572 const var_t *var;
573
574 offset = 0;
575 if (structure->fields) LIST_FOR_EACH_ENTRY( var, structure->fields, const var_t, entry )
576 {
577 unsigned int align = 0;
578 /* FIXME: take alignment into account */
579 if (var->name && !strcmp(var->name, subexpr->u.sval))
580 {
581 correlation_variable = var->type;
582 break;
583 }
584 offset += type_memsize(var->type, &align);
585 }
586 if (!correlation_variable)
587 error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
588 subexpr->u.sval);
589
590 offset -= baseoff;
591 correlation_type = RPC_FC_NORMAL_CONFORMANCE;
592 }
593 else
594 {
595 const var_t *var;
596
597 offset = sizeof(void *);
598 if (func->args) LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
599 {
600 if (!strcmp(var->name, subexpr->u.sval))
601 {
602 correlation_variable = var->type;
603 break;
604 }
605 /* FIXME: not all stack variables are sizeof(void *) */
606 offset += sizeof(void *);
607 }
608 if (!correlation_variable)
609 error("write_conf_or_var_desc: couldn't find variable %s in function\n",
610 subexpr->u.sval);
611
612 correlation_type = RPC_FC_TOP_LEVEL_CONFORMANCE;
613 }
614
615 correlation_variable_type = correlation_variable->type;
616
617 switch (correlation_variable_type)
618 {
619 case RPC_FC_CHAR:
620 case RPC_FC_SMALL:
621 param_type = RPC_FC_SMALL;
622 param_type_string = "FC_SMALL";
623 break;
624 case RPC_FC_BYTE:
625 case RPC_FC_USMALL:
626 param_type = RPC_FC_USMALL;
627 param_type_string = "FC_USMALL";
628 break;
629 case RPC_FC_WCHAR:
630 case RPC_FC_SHORT:
631 case RPC_FC_ENUM16:
632 param_type = RPC_FC_SHORT;
633 param_type_string = "FC_SHORT";
634 break;
635 case RPC_FC_USHORT:
636 param_type = RPC_FC_USHORT;
637 param_type_string = "FC_USHORT";
638 break;
639 case RPC_FC_LONG:
640 case RPC_FC_ENUM32:
641 param_type = RPC_FC_LONG;
642 param_type_string = "FC_LONG";
643 break;
644 case RPC_FC_ULONG:
645 param_type = RPC_FC_ULONG;
646 param_type_string = "FC_ULONG";
647 break;
648 case RPC_FC_RP:
649 case RPC_FC_UP:
650 case RPC_FC_OP:
651 case RPC_FC_FP:
652 if (sizeof(void *) == 4) /* FIXME */
653 {
654 param_type = RPC_FC_LONG;
655 param_type_string = "FC_LONG";
656 }
657 else
658 {
659 param_type = RPC_FC_HYPER;
660 param_type_string = "FC_HYPER";
661 }
662 break;
663 default:
664 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n",
665 correlation_variable_type);
666 }
667
668 print_file(file, 2, "0x%x, /* Corr desc: %s%s */\n",
669 correlation_type | param_type,
670 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "parameter, " : "",
671 param_type_string);
672 print_file(file, 2, "0x%x, /* %s */\n", operator_type, operator_string);
673 print_file(file, 2, "NdrFcShort(0x%x), /* %soffset = %d */\n",
674 offset,
675 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "x86 stack size / " : "",
676 offset);
677 }
678 else
679 {
680 unsigned int callback_offset = 0;
681
682 if (structure)
683 {
684 struct expr_eval_routine *eval;
685 int found = 0;
686
687 LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
688 {
689 if (!strcmp(eval->structure->name, structure->name) &&
690 !compare_expr(eval->expr, expr))
691 {
692 found = 1;
693 break;
694 }
695 callback_offset++;
696 }
697
698 if (!found)
699 {
700 unsigned int align = 0;
701 eval = xmalloc(sizeof(*eval));
702 eval->structure = structure;
703 eval->structure_size = fields_memsize(structure->fields, &align);
704 eval->expr = expr;
705 list_add_tail(&expr_eval_routines, &eval->entry);
706 }
707
708 correlation_type = RPC_FC_NORMAL_CONFORMANCE;
709 }
710 else
711 {
712 error("write_conf_or_var_desc: top-level callback conformance unimplemented\n");
713 correlation_type = RPC_FC_TOP_LEVEL_CONFORMANCE;
714 }
715
716 if (callback_offset > USHRT_MAX)
717 error("Maximum number of callback routines reached\n");
718
719 print_file(file, 2, "0x%x, /* Corr desc: %s */\n",
720 correlation_type,
721 correlation_type == RPC_FC_TOP_LEVEL_CONFORMANCE ? "parameter" : "");
722 print_file(file, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK");
723 print_file(file, 2, "NdrFcShort(0x%x), /* %u */\n", callback_offset, callback_offset);
724 }
725 return 4;
726 }
727
728 static size_t fields_memsize(const var_list_t *fields, unsigned int *align)
729 {
730 size_t size = 0;
731 const var_t *v;
732
733 if (!fields) return 0;
734 LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
735 size += type_memsize(v->type, align);
736
737 return size;
738 }
739
740 static size_t union_memsize(const var_list_t *fields, unsigned int *pmaxa)
741 {
742 size_t size, maxs = 0;
743 unsigned int align = *pmaxa;
744 const var_t *v;
745
746 if (fields) LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
747 {
748 /* we could have an empty default field with NULL type */
749 if (v->type)
750 {
751 size = type_memsize(v->type, &align);
752 if (maxs < size) maxs = size;
753 if (*pmaxa < align) *pmaxa = align;
754 }
755 }
756
757 return maxs;
758 }
759
760 size_t type_memsize(const type_t *t, unsigned int *align)
761 {
762 size_t size = 0;
763
764 if (t->declarray && is_conformant_array(t))
765 {
766 type_memsize(t->ref, align);
767 size = 0;
768 }
769 else if (is_ptr(t) || is_conformant_array(t))
770 {
771 size = sizeof(void *);
772 if (size > *align) *align = size;
773 }
774 else switch (t->type)
775 {
776 case RPC_FC_BYTE:
777 case RPC_FC_CHAR:
778 case RPC_FC_USMALL:
779 case RPC_FC_SMALL:
780 size = 1;
781 if (size > *align) *align = size;
782 break;
783 case RPC_FC_WCHAR:
784 case RPC_FC_USHORT:
785 case RPC_FC_SHORT:
786 case RPC_FC_ENUM16:
787 size = 2;
788 if (size > *align) *align = size;
789 break;
790 case RPC_FC_ULONG:
791 case RPC_FC_LONG:
792 case RPC_FC_ERROR_STATUS_T:
793 case RPC_FC_ENUM32:
794 case RPC_FC_FLOAT:
795 size = 4;
796 if (size > *align) *align = size;
797 break;
798 case RPC_FC_HYPER:
799 case RPC_FC_DOUBLE:
800 size = 8;
801 if (size > *align) *align = size;
802 break;
803 case RPC_FC_STRUCT:
804 case RPC_FC_CVSTRUCT:
805 case RPC_FC_CPSTRUCT:
806 case RPC_FC_CSTRUCT:
807 case RPC_FC_PSTRUCT:
808 case RPC_FC_BOGUS_STRUCT:
809 size = fields_memsize(t->fields, align);
810 break;
811 case RPC_FC_ENCAPSULATED_UNION:
812 case RPC_FC_NON_ENCAPSULATED_UNION:
813 size = union_memsize(t->fields, align);
814 break;
815 case RPC_FC_SMFARRAY:
816 case RPC_FC_LGFARRAY:
817 case RPC_FC_SMVARRAY:
818 case RPC_FC_LGVARRAY:
819 case RPC_FC_BOGUS_ARRAY:
820 size = t->dim * type_memsize(t->ref, align);
821 break;
822 default:
823 error("type_memsize: Unknown type %d\n", t->type);
824 size = 0;
825 }
826
827 return size;
828 }
829
830 static unsigned int write_nonsimple_pointer(FILE *file, const type_t *type, size_t offset)
831 {
832 short absoff = type->ref->typestring_offset;
833 short reloff = absoff - (offset + 2);
834 int ptr_attr = is_ptr(type->ref) ? 0x10 : 0x0;
835
836 print_file(file, 2, "0x%02x, 0x%x,\t/* %s */\n",
837 type->type, ptr_attr, string_of_type(type->type));
838 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%hd) */\n",
839 reloff, reloff, absoff);
840 return 4;
841 }
842
843 static unsigned int write_simple_pointer(FILE *file, const type_t *type)
844 {
845 print_file(file, 2, "0x%02x, 0x8,\t/* %s [simple_pointer] */\n",
846 type->type, string_of_type(type->type));
847 print_file(file, 2, "0x%02x,\t/* %s */\n", type->ref->type,
848 string_of_type(type->ref->type));
849 print_file(file, 2, "0x5c,\t/* FC_PAD */\n");
850 return 4;
851 }
852
853 static size_t write_pointer_tfs(FILE *file, type_t *type, unsigned int *typestring_offset)
854 {
855 unsigned int offset = *typestring_offset;
856
857 print_file(file, 0, "/* %d */\n", offset);
858 update_tfsoff(type, offset, file);
859
860 if (type->ref->typestring_offset)
861 *typestring_offset += write_nonsimple_pointer(file, type, offset);
862 else if (is_base_type(type->ref->type))
863 *typestring_offset += write_simple_pointer(file, type);
864
865 return offset;
866 }
867
868 static int processed(const type_t *type)
869 {
870 return type->typestring_offset && !type->tfswrite;
871 }
872
873 static void write_user_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
874 {
875 unsigned int start, absoff, flags;
876 unsigned int align = 0, ualign = 0;
877 const char *name;
878 type_t *utype = get_user_type(type, &name);
879 size_t usize = type_memsize(utype, &ualign);
880 size_t size = type_memsize(type, &align);
881 unsigned short funoff = user_type_offset(name);
882 short reloff;
883
884 guard_rec(type);
885
886 if (is_base_type(utype->type))
887 {
888 absoff = *tfsoff;
889 print_file(file, 0, "/* %d */\n", absoff);
890 print_file(file, 2, "0x%x,\t/* %s */\n", utype->type, string_of_type(utype->type));
891 print_file(file, 2, "0x5c,\t/* FC_PAD */\n");
892 *tfsoff += 2;
893 }
894 else
895 {
896 if (!processed(utype))
897 write_embedded_types(file, NULL, utype, utype->name, TRUE, tfsoff);
898 absoff = utype->typestring_offset;
899 }
900
901 if (utype->type == RPC_FC_RP)
902 flags = 0x40;
903 else if (utype->type == RPC_FC_UP)
904 flags = 0x80;
905 else
906 flags = 0;
907
908 start = *tfsoff;
909 update_tfsoff(type, start, file);
910 print_file(file, 0, "/* %d */\n", start);
911 print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", RPC_FC_USER_MARSHAL);
912 print_file(file, 2, "0x%x,\t/* Alignment= %d, Flags= %02x */\n",
913 flags | (align - 1), align - 1, flags);
914 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Function offset= %hu */\n", funoff, funoff);
915 print_file(file, 2, "NdrFcShort(0x%lx),\t/* %lu */\n", usize, usize);
916 print_file(file, 2, "NdrFcShort(0x%lx),\t/* %lu */\n", size, size);
917 *tfsoff += 8;
918 reloff = absoff - *tfsoff;
919 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%lu) */\n", reloff, reloff, absoff);
920 *tfsoff += 2;
921 }
922
923 static void write_member_type(FILE *file, type_t *type, const var_t *field,
924 unsigned int *corroff, unsigned int *tfsoff)
925 {
926 if (is_embedded_complex(type))
927 {
928 size_t absoff;
929 short reloff;
930
931 if (is_union(type->type) && is_attr(field->attrs, ATTR_SWITCHIS))
932 {
933 absoff = *corroff;
934 *corroff += 8;
935 }
936 else
937 {
938 absoff = type->typestring_offset;
939 }
940 reloff = absoff - (*tfsoff + 2);
941
942 print_file(file, 2, "0x4c,\t/* FC_EMBEDDED_COMPLEX */\n");
943 /* FIXME: actually compute necessary padding */
944 print_file(file, 2, "0x0,\t/* FIXME: padding */\n");
945 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%lu) */\n",
946 reloff, reloff, absoff);
947 *tfsoff += 4;
948 }
949 else if (is_ptr(type))
950 {
951 print_file(file, 2, "0x8,\t/* FC_LONG */\n");
952 *tfsoff += 1;
953 }
954 else if (!write_base_type(file, type, tfsoff))
955 error("Unsupported member type 0x%x\n", type->type);
956 }
957
958 static void write_end(FILE *file, unsigned int *tfsoff)
959 {
960 if (*tfsoff % 2 == 0)
961 {
962 print_file(file, 2, "0x%x,\t\t/* FC_PAD */\n", RPC_FC_PAD);
963 *tfsoff += 1;
964 }
965 print_file(file, 2, "0x%x,\t\t/* FC_END */\n", RPC_FC_END);
966 *tfsoff += 1;
967 }
968
969 static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
970 {
971 unsigned int offset = 0;
972 var_list_t *fs = type->fields;
973 var_t *f;
974
975 if (fs) LIST_FOR_EACH_ENTRY(f, fs, var_t, entry)
976 {
977 unsigned int align = 0;
978 type_t *ft = f->type;
979 if (is_union(ft->type) && is_attr(f->attrs, ATTR_SWITCHIS))
980 {
981 unsigned int absoff = ft->typestring_offset;
982 short reloff = absoff - (*tfsoff + 6);
983 print_file(file, 0, "/* %d */\n", *tfsoff);
984 print_file(file, 2, "0x%x,\t/* %s */\n", ft->type, string_of_type(ft->type));
985 print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", RPC_FC_LONG);
986 write_conf_or_var_desc(file, current_func, current_structure, offset,
987 get_attrp(f->attrs, ATTR_SWITCHIS));
988 print_file(file, 2, "NdrFcShort(%hd),\t/* Offset= %hd (%u) */\n",
989 reloff, reloff, absoff);
990 *tfsoff += 8;
991 }
992
993 /* FIXME: take alignment into account */
994 offset += type_memsize(ft, &align);
995 }
996 }
997
998 static int write_no_repeat_pointer_descriptions(
999 FILE *file, type_t *type,
1000 size_t *offset_in_memory, size_t *offset_in_buffer,
1001 unsigned int *typestring_offset)
1002 {
1003 int written = 0;
1004 unsigned int align;
1005
1006 if (is_ptr(type))
1007 {
1008 print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", RPC_FC_NO_REPEAT);
1009 print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD);
1010
1011 /* pointer instance */
1012 print_file(file, 2, "NdrFcShort(0x%x), /* Memory offset = %d */\n", *offset_in_memory, *offset_in_memory);
1013 print_file(file, 2, "NdrFcShort(0x%x), /* Buffer offset = %d */\n", *offset_in_buffer, *offset_in_buffer);
1014 *typestring_offset += 6;
1015
1016 if (processed(type->ref) || is_base_type(type->ref->type))
1017 write_pointer_tfs(file, type, typestring_offset);
1018 else
1019 error("write_pointer_description: type format string unknown\n");
1020
1021 align = 0;
1022 *offset_in_memory += type_memsize(type, &align);
1023 /* FIXME: is there a case where these two are different? */
1024 align = 0;
1025 *offset_in_buffer += type_memsize(type, &align);
1026
1027 return 1;
1028 }
1029
1030 if (is_non_complex_struct(type))
1031 {
1032 const var_t *v;
1033 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
1034 written += write_no_repeat_pointer_descriptions(
1035 file, v->type,
1036 offset_in_memory, offset_in_buffer, typestring_offset);
1037 }
1038 else
1039 {
1040 align = 0;
1041 *offset_in_memory += type_memsize(type, &align);
1042 /* FIXME: is there a case where these two are different? */
1043 align = 0;
1044 *offset_in_buffer += type_memsize(type, &align);
1045 }
1046
1047 return written;
1048 }
1049
1050 static int write_pointer_description_offsets(
1051 FILE *file, const attr_list_t *attrs, type_t *type,
1052 size_t *offset_in_memory, size_t *offset_in_buffer,
1053 unsigned int *typestring_offset)
1054 {
1055 int written = 0;
1056 unsigned int align;
1057
1058 if (is_ptr(type) && type->ref->type != RPC_FC_IP)
1059 {
1060 if (offset_in_memory && offset_in_buffer)
1061 {
1062 /* pointer instance */
1063 /* FIXME: sometimes from end of structure, sometimes from beginning */
1064 print_file(file, 2, "NdrFcShort(0x%x), /* Memory offset = %d */\n", *offset_in_memory, *offset_in_memory);
1065 print_file(file, 2, "NdrFcShort(0x%x), /* Buffer offset = %d */\n", *offset_in_buffer, *offset_in_buffer);
1066
1067 align = 0;
1068 *offset_in_memory += type_memsize(type, &align);
1069 /* FIXME: is there a case where these two are different? */
1070 align = 0;
1071 *offset_in_buffer += type_memsize(type, &align);
1072 }
1073 *typestring_offset += 4;
1074
1075 if (processed(type->ref) || is_base_type(type->ref->type))
1076 write_pointer_tfs(file, type, typestring_offset);
1077 else
1078 error("write_pointer_description_offsets: type format string unknown\n");
1079
1080 return 1;
1081 }
1082
1083 if (is_array(type))
1084 {
1085 return write_pointer_description_offsets(
1086 file, attrs, type->ref, offset_in_memory, offset_in_buffer,
1087 typestring_offset);
1088 }
1089 else if (is_non_complex_struct(type))
1090 {
1091 /* otherwise search for interesting fields to parse */
1092 const var_t *v;
1093 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
1094 {
1095 written += write_pointer_description_offsets(
1096 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1097 typestring_offset);
1098 }
1099 }
1100 else
1101 {
1102 align = 0;
1103 if (offset_in_memory)
1104 *offset_in_memory += type_memsize(type, &align);
1105 /* FIXME: is there a case where these two are different? */
1106 align = 0;
1107 if (offset_in_buffer)
1108 *offset_in_buffer += type_memsize(type, &align);
1109 }
1110
1111 return written;
1112 }
1113
1114 /* Note: if file is NULL return value is number of pointers to write, else
1115 * it is the number of type format characters written */
1116 static int write_fixed_array_pointer_descriptions(
1117 FILE *file, const attr_list_t *attrs, type_t *type,
1118 size_t *offset_in_memory, size_t *offset_in_buffer,
1119 unsigned int *typestring_offset)
1120 {
1121 unsigned int align;
1122 int pointer_count = 0;
1123
1124 if (type->type == RPC_FC_SMFARRAY || type->type == RPC_FC_LGFARRAY)
1125 {
1126 unsigned int temp = 0;
1127 /* unfortunately, this needs to be done in two passes to avoid
1128 * writing out redundant FC_FIXED_REPEAT descriptions */
1129 pointer_count = write_pointer_description_offsets(
1130 NULL, attrs, type->ref, NULL, NULL, &temp);
1131 if (pointer_count > 0)
1132 {
1133 unsigned int increment_size;
1134 size_t offset_of_array_pointer_mem = 0;
1135 size_t offset_of_array_pointer_buf = 0;
1136
1137 align = 0;
1138 increment_size = type_memsize(type->ref, &align);
1139
1140 print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", RPC_FC_FIXED_REPEAT);
1141 print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD);
1142 print_file(file, 2, "NdrFcShort(0x%x), /* Iterations = %d */\n", type->dim, type->dim);
1143 print_file(file, 2, "NdrFcShort(0x%x), /* Increment = %d */\n", increment_size, increment_size);
1144 print_file(file, 2, "NdrFcShort(0x%x), /* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
1145 print_file(file, 2, "NdrFcShort(0x%x), /* Number of pointers = %d */\n", pointer_count, pointer_count);
1146 *typestring_offset += 10;
1147
1148 pointer_count = write_pointer_description_offsets(
1149 file, attrs, type, &offset_of_array_pointer_mem,
1150 &offset_of_array_pointer_buf, typestring_offset);
1151 }
1152 }
1153 else if (is_struct(type->type))
1154 {
1155 const var_t *v;
1156 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
1157 {
1158 pointer_count += write_fixed_array_pointer_descriptions(
1159 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1160 typestring_offset);
1161 }
1162 }
1163 else
1164 {
1165 align = 0;
1166 if (offset_in_memory)
1167 *offset_in_memory += type_memsize(type, &align);
1168 /* FIXME: is there a case where these two are different? */
1169 align = 0;
1170 if (offset_in_buffer)
1171 *offset_in_buffer += type_memsize(type, &align);
1172 }
1173
1174 return pointer_count;
1175 }
1176
1177 /* Note: if file is NULL return value is number of pointers to write, else
1178 * it is the number of type format characters written */
1179 static int write_conformant_array_pointer_descriptions(
1180 FILE *file, const attr_list_t *attrs, type_t *type,
1181 size_t *offset_in_memory, size_t *offset_in_buffer,
1182 unsigned int *typestring_offset)
1183 {
1184 unsigned int align;
1185 int pointer_count = 0;
1186
1187 if (is_conformant_array(type) && !type->length_is)
1188 {
1189 unsigned int temp = 0;
1190 /* unfortunately, this needs to be done in two passes to avoid
1191 * writing out redundant FC_VARIABLE_REPEAT descriptions */
1192 pointer_count = write_pointer_description_offsets(
1193 NULL, attrs, type->ref, NULL, NULL, &temp);
1194 if (pointer_count > 0)
1195 {
1196 unsigned int increment_size;
1197 size_t offset_of_array_pointer_mem = 0;
1198 size_t offset_of_array_pointer_buf = 0;
1199
1200 align = 0;
1201 increment_size = type_memsize(type->ref, &align);
1202
1203 if (increment_size > USHRT_MAX)
1204 error("array size of %u bytes is too large\n", increment_size);
1205
1206 print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT);
1207 print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", RPC_FC_FIXED_OFFSET);
1208 print_file(file, 2, "NdrFcShort(0x%x), /* Increment = %d */\n", increment_size, increment_size);
1209 print_file(file, 2, "NdrFcShort(0x%x), /* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
1210 print_file(file, 2, "NdrFcShort(0x%x), /* Number of pointers = %d */\n", pointer_count, pointer_count);
1211 *typestring_offset += 8;
1212
1213 pointer_count = write_pointer_description_offsets(
1214 file, attrs, type->ref, &offset_of_array_pointer_mem,
1215 &offset_of_array_pointer_buf, typestring_offset);
1216 }
1217 }
1218 else if (is_struct(type->type))
1219 {
1220 const var_t *v;
1221 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
1222 {
1223 pointer_count += write_conformant_array_pointer_descriptions(
1224 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1225 typestring_offset);
1226 }
1227 }
1228 else
1229 {
1230 align = 0;
1231 if (offset_in_memory)
1232 *offset_in_memory += type_memsize(type, &align);
1233 /* FIXME: is there a case where these two are different? */
1234 align = 0;
1235 if (offset_in_buffer)
1236 *offset_in_buffer += type_memsize(type, &align);
1237 }
1238
1239 return pointer_count;
1240 }
1241
1242 /* Note: if file is NULL return value is number of pointers to write, else
1243 * it is the number of type format characters written */
1244 static int write_varying_array_pointer_descriptions(
1245 FILE *file, const attr_list_t *attrs, type_t *type,
1246 size_t *offset_in_memory, size_t *offset_in_buffer,
1247 unsigned int *typestring_offset)
1248 {
1249 unsigned int align;
1250 int pointer_count = 0;
1251
1252 /* FIXME: do varying array searching here, but pointer searching in write_pointer_description_offsets */
1253
1254 if (is_array(type) && type->length_is)
1255 {
1256 unsigned int temp = 0;
1257 /* unfortunately, this needs to be done in two passes to avoid
1258 * writing out redundant FC_VARIABLE_REPEAT descriptions */
1259 pointer_count = write_pointer_description_offsets(
1260 NULL, attrs, type->ref, NULL, NULL, &temp);
1261 if (pointer_count > 0)
1262 {
1263 unsigned int increment_size;
1264 size_t offset_of_array_pointer_mem = 0;
1265 size_t offset_of_array_pointer_buf = 0;
1266
1267 align = 0;
1268 increment_size = type_memsize(type->ref, &align);
1269
1270 if (increment_size > USHRT_MAX)
1271 error("array size of %u bytes is too large\n", increment_size);
1272
1273 print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT);
1274 print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", RPC_FC_VARIABLE_OFFSET);
1275 print_file(file, 2, "NdrFcShort(0x%x), /* Increment = %d */\n", increment_size, increment_size);
1276 print_file(file, 2, "NdrFcShort(0x%x), /* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
1277 print_file(file, 2, "NdrFcShort(0x%x), /* Number of pointers = %d */\n", pointer_count, pointer_count);
1278 *typestring_offset += 8;
1279
1280 pointer_count = write_pointer_description_offsets(
1281 file, attrs, type, &offset_of_array_pointer_mem,
1282 &offset_of_array_pointer_buf, typestring_offset);
1283 }
1284 }
1285 else if (is_struct(type->type))
1286 {
1287 const var_t *v;
1288 LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
1289 {
1290 pointer_count += write_varying_array_pointer_descriptions(
1291 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1292 typestring_offset);
1293 }
1294 }
1295 else
1296 {
1297 align = 0;
1298 if (offset_in_memory)
1299 *offset_in_memory += type_memsize(type, &align);
1300 /* FIXME: is there a case where these two are different? */
1301 align = 0;
1302 if (offset_in_buffer)
1303 *offset_in_buffer += type_memsize(type, &align);
1304 }
1305
1306 return pointer_count;
1307 }
1308
1309 static void write_pointer_description(FILE *file, type_t *type,
1310 unsigned int *typestring_offset)
1311 {
1312 size_t offset_in_buffer;
1313 size_t offset_in_memory;
1314
1315 /* pass 1: search for single instance of a pointer (i.e. don't descend
1316 * into arrays) */
1317 offset_in_memory = 0;
1318 offset_in_buffer = 0;
1319 write_no_repeat_pointer_descriptions(
1320 file, type,
1321 &offset_in_memory, &offset_in_buffer, typestring_offset);
1322
1323 /* pass 2: search for pointers in fixed arrays */
1324 offset_in_memory = 0;
1325 offset_in_buffer = 0;
1326 write_fixed_array_pointer_descriptions(
1327 file, NULL, type,
1328 &offset_in_memory, &offset_in_buffer, typestring_offset);
1329
1330 /* pass 3: search for pointers in conformant only arrays (but don't descend
1331 * into conformant varying or varying arrays) */
1332 offset_in_memory = 0;
1333 offset_in_buffer = 0;
1334 write_conformant_array_pointer_descriptions(
1335 file, NULL, type,
1336 &offset_in_memory, &offset_in_buffer, typestring_offset);
1337
1338 /* pass 4: search for pointers in varying arrays */
1339 offset_in_memory = 0;
1340 offset_in_buffer = 0;
1341 write_varying_array_pointer_descriptions(
1342 file, NULL, type,
1343 &offset_in_memory, &offset_in_buffer, typestring_offset);
1344 }
1345
1346 static size_t write_string_tfs(FILE *file, const attr_list_t *attrs,
1347 const type_t *type,
1348 const char *name, unsigned int *typestring_offset)
1349 {
1350 size_t start_offset = *typestring_offset;
1351 unsigned char flags = 0;
1352 int pointer_type;
1353 unsigned char rtype;
1354
1355 if (is_ptr(type))
1356 {
1357 pointer_type = type->type;
1358 type = type->ref;
1359 }
1360 else
1361 pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
1362
1363 if (!pointer_type)
1364 pointer_type = RPC_FC_RP;
1365
1366 if (!get_attrp(attrs, ATTR_SIZEIS))
1367 flags |= RPC_FC_P_SIMPLEPOINTER;
1368
1369 rtype = type->type;
1370
1371 if ((rtype != RPC_FC_BYTE) && (rtype != RPC_FC_CHAR) && (rtype != RPC_FC_WCHAR))
1372 {
1373 error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", rtype, name);
1374 return start_offset;
1375 }
1376
1377 print_file(file, 2,"0x%x, 0x%x, /* %s%s */\n",
1378 pointer_type, flags,
1379 pointer_type == RPC_FC_FP ? "FC_FP" : (pointer_type == RPC_FC_UP ? "FC_UP" : "FC_RP"),
1380 (flags & RPC_FC_P_SIMPLEPOINTER) ? " [simple_pointer]" : "");
1381 *typestring_offset += 2;
1382
1383 if (!(flags & RPC_FC_P_SIMPLEPOINTER))
1384 {
1385 print_file(file, 2, "NdrFcShort(0x2),\n");
1386 *typestring_offset += 2;
1387 }
1388
1389 if (type->declarray && !is_conformant_array(type))
1390 {
1391 /* FIXME: multi-dimensional array */
1392 if (0xffffuL < type->dim)
1393 error("array size for parameter %s exceeds %u bytes by %lu bytes\n",
1394 name, 0xffffu, type->dim - 0xffffu);
1395
1396 if (rtype == RPC_FC_CHAR)
1397 WRITE_FCTYPE(file, FC_CSTRING, *typestring_offset);
1398 else
1399 WRITE_FCTYPE(file, FC_WSTRING, *typestring_offset);
1400 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1401 *typestring_offset += 2;
1402
1403 print_file(file, 2, "NdrFcShort(0x%x), /* %d */\n", type->dim, type->dim);
1404 *typestring_offset += 2;
1405
1406 return start_offset;
1407 }
1408 else if (type->size_is)
1409 {
1410 unsigned int align = 0;
1411
1412 if (rtype == RPC_FC_CHAR)
1413 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
1414 else
1415 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
1416 print_file(file, 2, "0x%x, /* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED);
1417 *typestring_offset += 2;
1418
1419 *typestring_offset += write_conf_or_var_desc(
1420 file, current_func, current_structure,
1421 (type->declarray && current_structure
1422 ? type_memsize(current_structure, &align)
1423 : 0),
1424 type->size_is);
1425
1426 return start_offset;
1427 }
1428 else
1429 {
1430 if (rtype == RPC_FC_CHAR)
1431 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
1432 else
1433 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
1434 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1435 *typestring_offset += 2;
1436
1437 return start_offset;
1438 }
1439 }
1440
1441 static size_t write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type,
1442 const char *name, unsigned int *typestring_offset)
1443 {
1444 const expr_t *length_is = type->length_is;
1445 const expr_t *size_is = type->size_is;
1446 unsigned int align = 0;
1447 size_t size;
1448 size_t start_offset;
1449 int has_pointer;
1450 int pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
1451 if (!pointer_type)
1452 pointer_type = RPC_FC_RP;
1453
1454 has_pointer = FALSE;
1455 if (write_embedded_types(file, attrs, type->ref, name, FALSE, typestring_offset))
1456 has_pointer = TRUE;
1457
1458 size = type_memsize(type, &align);
1459 if (size == 0) /* conformant array */
1460 size = type_memsize(type->ref, &align);
1461
1462 start_offset = *typestring_offset;
1463 update_tfsoff(type, start_offset, file);
1464 print_file(file, 0, "/* %lu */\n", start_offset);
1465 print_file(file, 2, "0x%02x,\t/* %s */\n", type->type, string_of_type(type->type));
1466 print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
1467 *typestring_offset += 2;
1468
1469 align = 0;
1470 if (type->type != RPC_FC_BOGUS_ARRAY)
1471 {
1472 unsigned char tc = type->type;
1473 unsigned int baseoff
1474 = type->declarray && current_structure
1475 ? type_memsize(current_structure, &align)
1476 : 0;
1477
1478 if (tc == RPC_FC_LGFARRAY || tc == RPC_FC_LGVARRAY)
1479 {
1480 print_file(file, 2, "NdrFcLong(0x%x),\t/* %lu */\n", size, size);
1481 *typestring_offset += 4;
1482 }
1483 else
1484 {
1485 print_file(file, 2, "NdrFcShort(0x%x),\t/* %lu */\n", size, size);
1486 *typestring_offset += 2;
1487 }
1488
1489 if (is_conformant_array(type))
1490 *typestring_offset
1491 += write_conf_or_var_desc(file, current_func, current_structure,
1492 baseoff, size_is);
1493
1494 if (type->type == RPC_FC_SMVARRAY || type->type == RPC_FC_LGVARRAY)
1495 {
1496 unsigned int elalign = 0;
1497 size_t elsize = type_memsize(type->ref, &elalign);
1498
1499 if (type->type == RPC_FC_LGVARRAY)
1500 {
1501 print_file(file, 2, "NdrFcLong(0x%x),\t/* %lu */\n", type->dim, type->dim);
1502 *typestring_offset += 4;
1503 }
1504 else
1505 {
1506 print_file(file, 2, "NdrFcShort(0x%x),\t/* %lu */\n", type->dim, type->dim);
1507 *typestring_offset += 2;
1508 }
1509
1510 print_file(file, 2, "NdrFcShort(0x%x),\t/* %lu */\n", elsize, elsize);
1511 *typestring_offset += 2;
1512 }
1513
1514 if (length_is)
1515 *typestring_offset
1516 += write_conf_or_var_desc(file, current_func, current_structure,
1517 baseoff, length_is);
1518
1519 if (has_pointer)
1520 {
1521 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1522 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1523 *typestring_offset += 2;
1524 write_pointer_description(file, type, typestring_offset);
1525 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1526 *typestring_offset += 1;
1527 }
1528
1529 write_member_type(file, type->ref, NULL, NULL, typestring_offset);
1530 write_end(file, typestring_offset);
1531 }
1532 else
1533 error("%s: complex arrays unimplemented\n", name);
1534
1535 return start_offset;
1536 }
1537
1538 static const var_t *find_array_or_string_in_struct(const type_t *type)
1539 {
1540 const var_t *last_field = LIST_ENTRY( list_tail(type->fields), const var_t, entry );
1541 const type_t *ft = last_field->type;
1542
1543 if (ft->declarray && is_conformant_array(ft))
1544 return last_field;
1545
1546 if (ft->type == RPC_FC_CSTRUCT || ft->type == RPC_FC_CPSTRUCT || ft->type == RPC_FC_CVSTRUCT)
1547 return find_array_or_string_in_struct(last_field->type);
1548 else
1549 return NULL;
1550 }
1551
1552 static void write_struct_members(FILE *file, const type_t *type,
1553 unsigned int *corroff, unsigned int *typestring_offset)
1554 {
1555 const var_t *field;
1556
1557 if (type->fields) LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
1558 {
1559 type_t *ft = field->type;
1560 if (!ft->declarray || !is_conformant_array(ft))
1561 write_member_type(file, ft, field, corroff, typestring_offset);
1562 }
1563
1564 write_end(file, typestring_offset);
1565 }
1566
1567 static size_t write_struct_tfs(FILE *file, type_t *type,
1568 const char *name, unsigned int *tfsoff)
1569 {
1570 const type_t *save_current_structure = current_structure;
1571 unsigned int total_size;
1572 const var_t *array;
1573 size_t start_offset;
1574 size_t array_offset;
1575 int has_pointers = 0;
1576 unsigned int align = 0;
1577 unsigned int corroff;
1578 var_t *f;
1579
1580 guard_rec(type);
1581 current_structure = type;
1582
1583 total_size = type_memsize(type, &align);
1584 if (total_size > USHRT_MAX)
1585 error("structure size for %s exceeds %d bytes by %d bytes\n",
1586 name, USHRT_MAX, total_size - USHRT_MAX);
1587
1588 if (type->fields) LIST_FOR_EACH_ENTRY(f, type->fields, var_t, entry)
1589 has_pointers |= write_embedded_types(file, f->attrs, f->type, f->name,
1590 FALSE, tfsoff);
1591
1592 array = find_array_or_string_in_struct(type);
1593 if (array && !processed(array->type))
1594 array_offset
1595 = is_attr(array->attrs, ATTR_STRING)
1596 ? write_string_tfs(file, array->attrs, array->type, array->name, tfsoff)
1597 : write_array_tfs(file, array->attrs, array->type, array->name, tfsoff);
1598
1599 corroff = *tfsoff;
1600 write_descriptors(file, type, tfsoff);
1601
1602 start_offset = *tfsoff;
1603 update_tfsoff(type, start_offset, file);
1604 print_file(file, 0, "/* %d */\n", start_offset);
1605 print_file(file, 2, "0x%x,\t/* %s */\n", type->type, string_of_type(type->type));
1606 print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
1607 print_file(file, 2, "NdrFcShort(0x%x),\t/* %d */\n", total_size, total_size);
1608 *tfsoff += 4;
1609
1610 if (array)
1611 {
1612 unsigned int absoff = array->type->typestring_offset;
1613 short reloff = absoff - *tfsoff;
1614 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%lu) */\n",
1615 reloff, reloff, absoff);
1616 *tfsoff += 2;
1617 }
1618 else if (type->type == RPC_FC_BOGUS_STRUCT)
1619 {
1620 print_file(file, 2, "NdrFcShort(0x0),\n");
1621 *tfsoff += 2;
1622 }
1623
1624 if (type->type == RPC_FC_BOGUS_STRUCT)
1625 {
1626
1627 print_file(file, 2, "NdrFcShort(0x0),\t/* FIXME: pointer stuff */\n");
1628 *tfsoff += 2;
1629 }
1630 else if ((type->type == RPC_FC_PSTRUCT) ||
1631 (type->type == RPC_FC_CPSTRUCT) ||
1632 (type->type == RPC_FC_CVSTRUCT && has_pointers))
1633 {
1634 print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
1635 print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
1636 *tfsoff += 2;
1637 write_pointer_description(file, type, tfsoff);
1638 print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
1639 *tfsoff += 1;
1640 }
1641
1642 write_struct_members(file, type, &corroff, tfsoff);
1643
1644 current_structure = save_current_structure;
1645 return start_offset;
1646 }
1647
1648 static size_t write_pointer_only_tfs(FILE *file, const attr_list_t *attrs, int pointer_type,
1649 unsigned char flags, size_t offset,
1650 unsigned int *typeformat_offset)
1651 {
1652 size_t start_offset = *typeformat_offset;
1653 short reloff = offset - (*typeformat_offset + 2);
1654 int in_attr, out_attr;
1655 in_attr = is_attr(attrs, ATTR_IN);
1656 out_attr = is_attr(attrs, ATTR_OUT);
1657 if (!in_attr && !out_attr) in_attr = 1;
1658
1659 if (out_attr && !in_attr && pointer_type == RPC_FC_RP)
1660 flags |= 0x04;
1661
1662 print_file(file, 2, "0x%x, 0x%x,\t\t/* %s",
1663 pointer_type,
1664 flags,
1665 string_of_type(pointer_type));
1666 if (file)
1667 {
1668 if (flags & 0x04)
1669 fprintf(file, " [allocated_on_stack]");
1670 if (flags & 0x10)
1671 fprintf(file, " [pointer_deref]");
1672 fprintf(file, " */\n");
1673 }
1674
1675 print_file(file, 2, "NdrFcShort(0x%x),\t/* %d */\n", reloff, offset);
1676 *typeformat_offset += 4;
1677
1678 return start_offset;
1679 }
1680
1681 static void write_branch_type(FILE *file, const type_t *t, unsigned int *tfsoff)
1682 {
1683 if (t == NULL)
1684 {
1685 print_file(file, 2, "NdrFcShort(0x0),\t/* No type */\n");
1686 }
1687 else if (is_base_type(t->type))
1688 {
1689 print_file(file, 2, "NdrFcShort(0x80%02x),\t/* Simple arm type: %s */\n",
1690 t->type, string_of_type(t->type));
1691 }
1692 else if (t->typestring_offset)
1693 {
1694 short reloff = t->typestring_offset - *tfsoff;
1695 print_file(file, 2, "NdrFcShort(0x%x),\t/* Offset= %d (%d) */\n",
1696 reloff, reloff, t->typestring_offset);
1697 }
1698 else
1699 error("write_branch_type: type unimplemented (0x%x)\n", t->type);
1700
1701 *tfsoff += 2;
1702 }
1703
1704 static size_t write_union_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
1705 {
1706 unsigned int align = 0;
1707 unsigned int start_offset;
1708 size_t size = type_memsize(type, &align);
1709 var_list_t *fields;
1710 size_t nbranch = 0;
1711 type_t *deftype = NULL;
1712 short nodeftype = 0xffff;
1713 var_t *f;
1714
1715 guard_rec(type);
1716
1717 if (type->type == RPC_FC_ENCAPSULATED_UNION)
1718 {
1719 const var_t *uv = LIST_ENTRY(list_tail(type->fields), const var_t, entry);
1720 fields = uv->type->fields;
1721 }
1722 else
1723 fields = type->fields;
1724
1725 if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
1726 {
1727 expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE);
1728 if (cases)
1729 nbranch += list_count(cases);
1730 if (f->type)
1731 write_embedded_types(file, f->attrs, f->type, f->name, TRUE, tfsoff);
1732 }
1733
1734 start_offset = *tfsoff;
1735 update_tfsoff(type, start_offset, file);
1736 print_file(file, 0, "/* %d */\n", start_offset);
1737 if (type->type == RPC_FC_ENCAPSULATED_UNION)
1738 {
1739 const var_t *sv = LIST_ENTRY(list_head(type->fields), const var_t, entry);
1740 const type_t *st = sv->type;
1741
1742 switch (st->type)
1743 {
1744 case RPC_FC_CHAR:
1745 case RPC_FC_SMALL:
1746 case RPC_FC_USMALL:
1747 case RPC_FC_SHORT:
1748 case RPC_FC_USHORT:
1749 case RPC_FC_LONG:
1750 case RPC_FC_ULONG:
1751 case RPC_FC_ENUM16:
1752 case RPC_FC_ENUM32:
1753 print_file(file, 2, "0x%x,\t/* %s */\n", type->type, string_of_type(type->type));
1754 print_file(file, 2, "0x%x,\t/* Switch type= %s */\n",
1755 0x40 | st->type, string_of_type(st->type));
1756 *tfsoff += 2;
1757 break;
1758 default:
1759 error("union switch type must be an integer, char, or enum\n");
1760 }
1761 }
1762 print_file(file, 2, "NdrFcShort(0x%x),\t/* %d */\n", size, size);
1763 print_file(file, 2, "NdrFcShort(0x%x),\t/* %d */\n", nbranch, nbranch);
1764 *tfsoff += 4;
1765
1766 if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
1767 {
1768 type_t *ft = f->type;
1769 expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE);
1770 int deflt = is_attr(f->attrs, ATTR_DEFAULT);
1771 expr_t *c;
1772
1773 if (cases == NULL && !deflt)
1774 error("union field %s with neither case nor default attribute\n", f->name);
1775
1776 if (cases) LIST_FOR_EACH_ENTRY(c, cases, expr_t, entry)
1777 {
1778 /* MIDL doesn't check for duplicate cases, even though that seems
1779 like a reasonable thing to do, it just dumps them to the TFS
1780 like we're going to do here. */
1781 print_file(file, 2, "NdrFcLong(0x%x),\t/* %d */\n", c->cval, c->cval);
1782 *tfsoff += 4;
1783 write_branch_type(file, ft, tfsoff);
1784 }
1785
1786 /* MIDL allows multiple default branches, even though that seems
1787 illogical, it just chooses the last one, which is what we will
1788 do. */
1789 if (deflt)
1790 {
1791 deftype = ft;
1792 nodeftype = 0;
1793 }
1794 }
1795
1796 if (deftype)
1797 {
1798 write_branch_type(file, deftype, tfsoff);
1799 }
1800 else
1801 {
1802 print_file(file, 2, "NdrFcShort(0x%x),\n", nodeftype);
1803 *tfsoff += 2;
1804 }
1805
1806 return start_offset;
1807 }
1808
1809 static size_t write_ip_tfs(FILE *file, const func_t *func, const attr_list_t *attrs,
1810 type_t *type, unsigned int *typeformat_offset)
1811 {
1812 size_t i;
1813 size_t start_offset = *typeformat_offset;
1814 const var_t *iid = get_attrp(attrs, ATTR_IIDIS);
1815
1816 if (iid)
1817 {
1818 expr_t expr;
1819
1820 expr.type = EXPR_IDENTIFIER;
1821 expr.ref = NULL;
1822 expr.u.sval = iid->name;
1823 expr.is_const = FALSE;
1824 print_file(file, 2, "0x2f, /* FC_IP */\n");
1825 print_file(file, 2, "0x5c, /* FC_PAD */\n");
1826 *typeformat_offset += write_conf_or_var_desc(file, func, NULL, 0, &expr) + 2;
1827 }
1828 else
1829 {
1830 const type_t *base = is_ptr(type) ? type->ref : type;
1831 const UUID *uuid = get_attrp(base->attrs, ATTR_UUID);
1832
1833 if (! uuid)
1834 error("%s: interface %s missing UUID\n", __FUNCTION__, base->name);
1835
1836 update_tfsoff(type, start_offset, file);
1837 print_file(file, 0, "/* %d */\n", start_offset);
1838 print_file(file, 2, "0x2f,\t/* FC_IP */\n");
1839 print_file(file, 2, "0x5a,\t/* FC_CONSTANT_IID */\n");
1840 print_file(file, 2, "NdrFcLong(0x%08lx),\n", uuid->Data1);
1841 print_file(file, 2, "NdrFcShort(0x%04x),\n", uuid->Data2);
1842 print_file(file, 2, "NdrFcShort(0x%04x),\n", uuid->Data3);
1843 for (i = 0; i < 8; ++i)
1844 print_file(file, 2, "0x%02x,\n", uuid->Data4[i]);
1845
1846 if (file)
1847 fprintf(file, "\n");
1848
1849 *typeformat_offset += 18;
1850 }
1851 return start_offset;
1852 }
1853
1854 static int get_ptr_attr(const type_t *t, int def_type)
1855 {
1856 while (TRUE)
1857 {
1858 int ptr_attr = get_attrv(t->attrs, ATTR_POINTERTYPE);
1859 if (ptr_attr)
1860 return ptr_attr;
1861 if (t->kind != TKIND_ALIAS)
1862 return def_type;
1863 t = t->orig;
1864 }
1865 }
1866
1867 static size_t write_typeformatstring_var(FILE *file, int indent, const func_t *func,
1868 type_t *type, const var_t *var,
1869 unsigned int *typeformat_offset)
1870 {
1871 int pointer_type;
1872 size_t offset;
1873
1874 if (is_user_type(type))
1875 {
1876 write_user_tfs(file, type, typeformat_offset);
1877 return type->typestring_offset;
1878 }
1879
1880 if (type == var->type) /* top-level pointers */
1881 {
1882 int pointer_attr = get_attrv(var->attrs, ATTR_POINTERTYPE);
1883 if (pointer_attr != 0 && !is_ptr(type) && !is_array(type))
1884 error("'%s': pointer attribute applied to non-pointer type\n", var->name);
1885
1886 if (pointer_attr == 0)
1887 pointer_attr = get_ptr_attr(type, RPC_FC_RP);
1888
1889 pointer_type = pointer_attr;
1890 }
1891 else
1892 pointer_type = get_ptr_attr(type, RPC_FC_UP);
1893
1894 if ((last_ptr(type) || last_array(type)) && is_ptrchain_attr(var, ATTR_STRING))
1895 return write_string_tfs(file, var->attrs, type, var->name, typeformat_offset);
1896
1897 if (is_array(type))
1898 return write_array_tfs(file, var->attrs, type, var->name, typeformat_offset);
1899
1900 if (!is_ptr(type))
1901 {
1902 /* basic types don't need a type format string */
1903 if (is_base_type(type->type))
1904 return 0;
1905
1906 switch (type->type)
1907 {
1908 case RPC_FC_STRUCT:
1909 case RPC_FC_PSTRUCT:
1910 case RPC_FC_CSTRUCT:
1911 case RPC_FC_CPSTRUCT:
1912 case RPC_FC_CVSTRUCT:
1913 case RPC_FC_BOGUS_STRUCT:
1914 return write_struct_tfs(file, type, var->name, typeformat_offset);
1915 case RPC_FC_ENCAPSULATED_UNION:
1916 case RPC_FC_NON_ENCAPSULATED_UNION:
1917 return write_union_tfs(file, type, typeformat_offset);
1918 case RPC_FC_IGNORE:
1919 case RPC_FC_BIND_PRIMITIVE:
1920 /* nothing to do */
1921 return 0;
1922 default:
1923 error("write_typeformatstring_var: Unsupported type 0x%x for variable %s\n", type->type, var->name);
1924 }
1925 }
1926 else if (last_ptr(type))
1927 {
1928 size_t start_offset = *typeformat_offset;
1929 int in_attr = is_attr(var->attrs, ATTR_IN);
1930 int out_attr = is_attr(var->attrs, ATTR_OUT);
1931 const type_t *base = type->ref;
1932
1933 if (base->type == RPC_FC_IP)
1934 {
1935 return write_ip_tfs(file, func, var->attrs, type, typeformat_offset);
1936 }
1937
1938 /* special case for pointers to base types */
1939 if (is_base_type(base->type))
1940 {
1941 print_file(file, indent, "0x%x, 0x%x, /* %s %s[simple_pointer] */\n",
1942 pointer_type, (!in_attr && out_attr) ? 0x0C : 0x08,
1943 string_of_type(pointer_type),
1944 (!in_attr && out_attr) ? "[allocated_on_stack] " : "");
1945 print_file(file, indent, "0x%02x, /* %s */\n", base->type, string_of_type(base->type));
1946 print_file(file, indent, "0x5c, /* FC_PAD */\n");
1947 *typeformat_offset += 4;
1948 return start_offset;
1949 }
1950 }
1951
1952 assert(is_ptr(type));
1953
1954 offset = write_typeformatstring_var(file, indent, func, type->ref, var, typeformat_offset);
1955 if (file)
1956 fprintf(file, "/* %2u */\n", *typeformat_offset);
1957 return write_pointer_only_tfs(file, var->attrs, pointer_type,
1958 !last_ptr(type) ? 0x10 : 0,
1959 offset, typeformat_offset);
1960 }
1961
1962 static void set_tfswrite(type_t *type, int val)
1963 {
1964 while (type->tfswrite != val)
1965 {
1966 type_t *utype = get_user_type(type, NULL);
1967
1968 type->tfswrite = val;
1969
1970 if (utype)
1971 set_tfswrite(utype, val);
1972
1973 if (type->kind == TKIND_ALIAS)
1974 type = type->orig;
1975 else if (is_ptr(type) || is_array(type))
1976 type = type->ref;
1977 else
1978 {
1979 if (type->fields)
1980 {
1981 var_t *v;
1982 LIST_FOR_EACH_ENTRY( v, type->fields, var_t, entry )
1983 if (v->type)
1984 set_tfswrite(v->type, val);
1985 }
1986
1987 return;
1988 }
1989 }
1990 }
1991
1992 static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
1993 const char *name, int write_ptr, unsigned int *tfsoff)
1994 {
1995 int retmask = 0;
1996
1997 if (is_user_type(type))
1998 {
1999 write_user_tfs(file, type, tfsoff);
2000 }
2001 else if (is_ptr(type))
2002 {
2003 type_t *ref = type->ref;
2004
2005 if (ref->type == RPC_FC_IP)
2006 {
2007 write_ip_tfs(file, NULL, attrs, type, tfsoff);
2008 }
2009 else
2010 {
2011 if (!processed(ref) && !is_base_type(ref->type))
2012 retmask |= write_embedded_types(file, NULL, ref, name, TRUE, tfsoff);
2013
2014 if (write_ptr)
2015 write_pointer_tfs(file, type, tfsoff);
2016
2017 retmask |= 1;
2018 }
2019 }
2020 else if (type->declarray && is_conformant_array(type))
2021 ; /* conformant arrays and strings are handled specially */
2022 else if (is_array(type))
2023 {
2024 write_array_tfs(file, attrs, type, name, tfsoff);
2025 }
2026 else if (is_struct(type->type))
2027 {
2028 if (!processed(type))
2029 write_struct_tfs(file, type, name, tfsoff);
2030 }
2031 else if (is_union(type->type))
2032 {
2033 if (!processed(type))
2034 write_union_tfs(file, type, tfsoff);
2035 }
2036 else if (!is_base_type(type->type))
2037 error("write_embedded_types: unknown embedded type for %s (0x%x)\n",
2038 name, type->type);
2039
2040 return retmask;
2041 }
2042
2043 static void set_all_tfswrite(const ifref_list_t *ifaces, int val)
2044 {
2045 const ifref_t * iface;
2046 const func_t *func;
2047 const var_t *var;
2048
2049 if (ifaces)
2050 LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
2051 if (iface->iface->funcs)
2052 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
2053 if (func->args)
2054 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2055 set_tfswrite(var->type, val);
2056 }
2057
2058 static size_t process_tfs(FILE *file, const ifref_list_t *ifaces, int for_objects)
2059 {
2060 const var_t *var;
2061 const ifref_t *iface;
2062 unsigned int typeformat_offset = 2;
2063
2064 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
2065 {
2066 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
2067 continue;
2068
2069 if (iface->iface->funcs)
2070 {
2071 const func_t *func;
2072 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
2073 {
2074 if (is_local(func->def->attrs)) continue;
2075
2076 current_func = func;
2077 if (func->args)
2078 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2079 update_tfsoff(
2080 var->type,
2081 write_typeformatstring_var(
2082 file, 2, func, var->type, var,
2083 &typeformat_offset),
2084 file);
2085 }
2086 }
2087 }
2088
2089 return typeformat_offset + 1;
2090 }
2091
2092
2093 void write_typeformatstring(FILE *file, const ifref_list_t *ifaces, int for_objects)
2094 {
2095 int indent = 0;
2096
2097 print_file(file, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
2098 print_file(file, indent, "{\n");
2099 indent++;
2100 print_file(file, indent, "0,\n");
2101 print_file(file, indent, "{\n");
2102 indent++;
2103 print_file(file, indent, "NdrFcShort(0x0),\n");
2104
2105 set_all_tfswrite(ifaces, TRUE);
2106 process_tfs(file, ifaces, for_objects);
2107
2108 print_file(file, indent, "0x0\n");
2109 indent--;
2110 print_file(file, indent, "}\n");
2111 indent--;
2112 print_file(file, indent, "};\n");
2113 print_file(file, indent, "\n");
2114 }
2115
2116 static unsigned int get_required_buffer_size_type(
2117 const type_t *type, const char *name, unsigned int *alignment)
2118 {
2119 size_t size = 0;
2120
2121 *alignment = 0;
2122 if (is_user_type(type))
2123 {
2124 const char *uname;
2125 const type_t *utype = get_user_type(type, &uname);
2126 size = get_required_buffer_size_type(utype, uname, alignment);
2127 }
2128 else if (!is_ptr(type))
2129 {
2130 switch (type->type)
2131 {
2132 case RPC_FC_BYTE:
2133 case RPC_FC_CHAR:
2134 case RPC_FC_USMALL:
2135 case RPC_FC_SMALL:
2136 *alignment = 4;
2137 size = 1;
2138 break;
2139
2140 case RPC_FC_WCHAR:
2141 case RPC_FC_USHORT:
2142 case RPC_FC_SHORT:
2143 case RPC_FC_ENUM16:
2144 *alignment = 4;
2145 size = 2;
2146 break;
2147
2148 case RPC_FC_ULONG:
2149 case RPC_FC_LONG:
2150 case RPC_FC_ENUM32:
2151 case RPC_FC_FLOAT:
2152 case RPC_FC_ERROR_STATUS_T:
2153 *alignment = 4;
2154 size = 4;
2155 break;
2156
2157 case RPC_FC_HYPER:
2158 case RPC_FC_DOUBLE:
2159 *alignment = 8;
2160 size = 8;
2161 break;
2162
2163 case RPC_FC_IGNORE:
2164 case RPC_FC_BIND_PRIMITIVE:
2165 return 0;
2166
2167 case RPC_FC_STRUCT:
2168 case RPC_FC_PSTRUCT:
2169 {
2170 const var_t *field;
2171 if (!type->fields) return 0;
2172 LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
2173 {
2174 unsigned int alignment;
2175 size += get_required_buffer_size_type(field->type, field->name,
2176 &alignment);
2177 }
2178 break;
2179 }
2180
2181 case RPC_FC_RP:
2182 if (is_base_type( type->ref->type ) || type->ref->type == RPC_FC_STRUCT)
2183 size = get_required_buffer_size_type( type->ref, name, alignment );
2184 break;
2185
2186 case RPC_FC_SMFARRAY:
2187 case RPC_FC_LGFARRAY:
2188 size = type->dim * get_required_buffer_size_type(type->ref, name, alignment);
2189 break;
2190
2191 case RPC_FC_SMVARRAY:
2192 case RPC_FC_LGVARRAY:
2193 get_required_buffer_size_type(type->ref, name, alignment);
2194 size = 0;
2195 break;
2196
2197 case RPC_FC_CARRAY:
2198 case RPC_FC_CVARRAY:
2199 get_required_buffer_size_type(type->ref, name, alignment);
2200 size = sizeof(void *);
2201 break;
2202
2203 default:
2204 error("get_required_buffer_size: Unknown/unsupported type: %s (0x%02x)\n", name, type->type);
2205 return 0;
2206 }
2207 }
2208 return size;
2209 }
2210
2211 static unsigned int get_required_buffer_size(const var_t *var, unsigned int *alignment, enum pass pass)
2212 {
2213 int in_attr = is_attr(var->attrs, ATTR_IN);
2214 int out_attr = is_attr(var->attrs, ATTR_OUT);
2215
2216 if (!in_attr && !out_attr)
2217 in_attr = 1;
2218
2219 *alignment = 0;
2220
2221 if (pass == PASS_OUT)
2222 {
2223 if (out_attr && is_ptr(var->type))
2224 {
2225 type_t *type = var->type;
2226
2227 if (type->type == RPC_FC_STRUCT)
2228 {
2229 const var_t *field;
2230 unsigned int size = 36;
2231
2232 if (!type->fields) return size;
2233 LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
2234 {
2235 unsigned int align;
2236 size += get_required_buffer_size_type(
2237 field->type, field->name, &align);
2238 }
2239 return size;
2240 }
2241 }
2242 return 0;
2243 }
2244 else
2245 {
2246 if ((!out_attr || in_attr) && !var->type->size_is
2247 && !is_attr(var->attrs, ATTR_STRING) && !var->type->declarray)
2248 {
2249 if (is_ptr(var->type))
2250 {
2251 type_t *type = var->type;
2252
2253 if (is_base_type(type->type))
2254 {
2255 return 25;
2256 }
2257 else if (type->type == RPC_FC_STRUCT)
2258 {
2259 unsigned int size = 36;
2260 const var_t *field;
2261
2262 if (!type->fields) return size;
2263 LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
2264 {
2265 unsigned int align;
2266 size += get_required_buffer_size_type(
2267 field->type, field->name, &align);
2268 }
2269 return size;
2270 }
2271 }
2272 }
2273
2274 return get_required_buffer_size_type(var->type, var->name, alignment);
2275 }
2276 }
2277
2278 static unsigned int get_function_buffer_size( const func_t *func, enum pass pass )
2279 {
2280 const var_t *var;
2281 unsigned int total_size = 0, alignment;
2282
2283 if (func->args)
2284 {
2285 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2286 {
2287 total_size += get_required_buffer_size(var, &alignment, pass);
2288 total_size += alignment;
2289 }
2290 }
2291
2292 if (pass == PASS_OUT && !is_void(func->def->type))
2293 {
2294 total_size += get_required_buffer_size(func->def, &alignment, PASS_RETURN);
2295 total_size += alignment;
2296 }
2297 return total_size;
2298 }
2299
2300 static void print_phase_function(FILE *file, int indent, const char *type,
2301 enum remoting_phase phase,
2302 const var_t *var, unsigned int type_offset)
2303 {
2304 const char *function;
2305 switch (phase)
2306 {
2307 case PHASE_BUFFERSIZE:
2308 function = "BufferSize";
2309 break;
2310 case PHASE_MARSHAL:
2311 function = "Marshall";
2312 break;
2313 case PHASE_UNMARSHAL:
2314 function = "Unmarshall";
2315 break;
2316 case PHASE_FREE:
2317 function = "Free";
2318 break;
2319 default:
2320 assert(0);
2321 return;
2322 }
2323
2324 print_file(file, indent, "Ndr%s%s(\n", type, function);
2325 indent++;
2326 print_file(file, indent, "&_StubMsg,\n");
2327 print_file(file, indent, "%s%s%s%s,\n",
2328 (phase == PHASE_UNMARSHAL) ? "(unsigned char **)" : "(unsigned char *)",
2329 (phase == PHASE_UNMARSHAL || decl_indirect(var->type)) ? "&" : "",
2330 (phase == PHASE_UNMARSHAL && decl_indirect(var->type)) ? "_p_" : "",
2331 var->name);
2332 print_file(file, indent, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n",
2333 type_offset, (phase == PHASE_UNMARSHAL) ? "," : ");");
2334 if (phase == PHASE_UNMARSHAL)
2335 print_file(file, indent, "0);\n");
2336 indent--;
2337 }
2338
2339 void print_phase_basetype(FILE *file, int indent, enum remoting_phase phase,
2340 enum pass pass, const var_t *var,
2341 const char *varname)
2342 {
2343 type_t *type = var->type;
2344 unsigned int size;
2345 unsigned int alignment = 0;
2346 unsigned char rtype;
2347
2348 /* no work to do for other phases, buffer sizing is done elsewhere */
2349 if (phase != PHASE_MARSHAL && phase != PHASE_UNMARSHAL)
2350 return;
2351
2352 rtype = is_ptr(type) ? type->ref->type : type->type;
2353
2354 switch (rtype)
2355 {
2356 case RPC_FC_BYTE:
2357 case RPC_FC_CHAR:
2358 case RPC_FC_SMALL:
2359 case RPC_FC_USMALL:
2360 size = 1;
2361 alignment = 1;
2362 break;
2363
2364 case RPC_FC_WCHAR:
2365 case RPC_FC_USHORT:
2366 case RPC_FC_SHORT:
2367 case RPC_FC_ENUM16:
2368 size = 2;
2369 alignment = 2;
2370 break;
2371
2372 case RPC_FC_ULONG:
2373 case RPC_FC_LONG:
2374 case RPC_FC_ENUM32:
2375 case RPC_FC_FLOAT:
2376 case RPC_FC_ERROR_STATUS_T:
2377 size = 4;
2378 alignment = 4;
2379 break;
2380
2381 case RPC_FC_HYPER:
2382 case RPC_FC_DOUBLE:
2383 size = 8;
2384 alignment = 8;
2385 break;
2386
2387 case RPC_FC_IGNORE:
2388 case RPC_FC_BIND_PRIMITIVE:
2389 /* no marshalling needed */
2390 return;
2391
2392 default:
2393 error("print_phase_basetype: Unsupported type: %s (0x%02x, ptr_level: 0)\n", var->name, rtype);
2394 size = 0;
2395 }
2396
2397 print_file(file, indent, "_StubMsg.Buffer = (unsigned char *)(((long)_StubMsg.Buffer + %u) & ~0x%x);\n",
2398 alignment - 1, alignment - 1);
2399
2400 if (phase == PHASE_MARSHAL)
2401 {
2402 print_file(file, indent, "*(");
2403 write_type(file, is_ptr(type) ? type->ref : type, FALSE, NULL);
2404 if (is_ptr(type))
2405 fprintf(file, " *)_StubMsg.Buffer = *");
2406 else
2407 fprintf(file, " *)_StubMsg.Buffer = ");
2408 fprintf(file, varname);
2409 fprintf(file, ";\n");
2410 }
2411 else if (phase == PHASE_UNMARSHAL)
2412 {
2413 if (pass == PASS_IN || pass == PASS_RETURN)
2414 print_file(file, indent, "");
2415 else
2416 print_file(file, indent, "*");
2417 fprintf(file, varname);
2418 if (pass == PASS_IN && is_ptr(type))
2419 fprintf(file, " = (");
2420 else
2421 fprintf(file, " = *(");
2422 write_type(file, is_ptr(type) ? type->ref : type, FALSE, NULL);
2423 fprintf(file, " *)_StubMsg.Buffer;\n");
2424 }
2425
2426 print_file(file, indent, "_StubMsg.Buffer += sizeof(");
2427 write_type(file, var->type, FALSE, NULL);
2428 fprintf(file, ");\n");
2429 }
2430
2431 /* returns whether the MaxCount, Offset or ActualCount members need to be
2432 * filled in for the specified phase */
2433 static inline int is_size_needed_for_phase(enum remoting_phase phase)
2434 {
2435 return (phase != PHASE_UNMARSHAL);
2436 }
2437
2438 void write_remoting_arguments(FILE *file, int indent, const func_t *func,
2439 enum pass pass, enum remoting_phase phase)
2440 {
2441 int in_attr, out_attr, pointer_type;
2442 const var_t *var;
2443
2444 if (!func->args)
2445 return;
2446
2447 if (phase == PHASE_BUFFERSIZE)
2448 {
2449 unsigned int size = get_function_buffer_size( func, pass );
2450 print_file(file, indent, "_StubMsg.BufferLength = %u;\n", size);
2451 }
2452
2453 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2454 {
2455 const type_t *type = var->type;
2456 unsigned char rtype;
2457 size_t start_offset = type->typestring_offset;
2458
2459 pointer_type = get_attrv(var->attrs, ATTR_POINTERTYPE);
2460 if (!pointer_type)
2461 pointer_type = RPC_FC_RP;
2462
2463 in_attr = is_attr(var->attrs, ATTR_IN);
2464 out_attr = is_attr(var->attrs, ATTR_OUT);
2465 if (!in_attr && !out_attr)
2466 in_attr = 1;
2467
2468 switch (pass)
2469 {
2470 case PASS_IN:
2471 if (!in_attr) continue;
2472 break;
2473 case PASS_OUT:
2474 if (!out_attr) continue;
2475 break;
2476 case PASS_RETURN:
2477 break;
2478 }
2479
2480 rtype = type->type;
2481
2482 if (is_user_type(var->type))
2483 {
2484 print_phase_function(file, indent, "UserMarshal", phase, var, start_offset);
2485 }
2486 else if (is_string_type(var->attrs, var->type))
2487 {
2488 if (is_array(type) && !is_conformant_array(type))
2489 print_phase_function(file, indent, "NonConformantString", phase, var, start_offset);
2490 else
2491 {
2492 if (type->size_is && is_size_needed_for_phase(phase))
2493 {
2494 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
2495 write_expr(file, type->size_is, 1);
2496 fprintf(file, ";\n");
2497 }
2498
2499 if ((phase == PHASE_FREE) || (pointer_type == RPC_FC_UP))
2500 print_phase_function(file, indent, "Pointer", phase, var, start_offset);
2501 else
2502 print_phase_function(file, indent, "ConformantString", phase, var,
2503 start_offset + (type->size_is ? 4 : 2));
2504 }
2505 }
2506 else if (is_array(type))
2507 {
2508 unsigned char tc = type->type;
2509 const char *array_type;
2510
2511 if (tc == RPC_FC_SMFARRAY || tc == RPC_FC_LGFARRAY)
2512 array_type = "FixedArray";
2513 else if (tc == RPC_FC_SMVARRAY || tc == RPC_FC_LGVARRAY)
2514 {
2515 if (is_size_needed_for_phase(phase))
2516 {
2517 print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
2518 print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
2519 write_expr(file, type->length_is, 1);
2520 fprintf(file, ";\n\n");
2521 }
2522 array_type = "VaryingArray";
2523 }
2524 else if (tc == RPC_FC_CARRAY)
2525 {
2526 if (is_size_needed_for_phase(phase) && phase != PHASE_FREE)
2527 {
2528 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
2529 write_expr(file, type->size_is, 1);
2530 fprintf(file, ";\n\n");
2531 }
2532 array_type = "ConformantArray";
2533 }
2534 else if (tc == RPC_FC_CVARRAY)
2535 {
2536 if (is_size_needed_for_phase(phase))
2537 {
2538 print_file(file, indent, "_StubMsg.MaxCount = (unsigned long)");
2539 write_expr(file, type->size_is, 1);
2540 fprintf(file, ";\n");
2541 print_file(file, indent, "_StubMsg.Offset = (unsigned long)0;\n"); /* FIXME */
2542 print_file(file, indent, "_StubMsg.ActualCount = (unsigned long)");
2543 write_expr(file, type->length_is, 1);
2544 fprintf(file, ";\n\n");
2545 }
2546 array_type = "ConformantVaryingArray";
2547 }
2548 else
2549 array_type = "ComplexArray";
2550
2551 if (!in_attr && phase == PHASE_FREE)
2552 {
2553 print_file(file, indent, "if (%s)\n", var->name);
2554 indent++;
2555 print_file(file, indent, "_StubMsg.pfnFree(%s);\n", var->name);
2556 }
2557 else if (phase != PHASE_FREE)
2558 {
2559 if (pointer_type == RPC_FC_UP)
2560 print_phase_function(file, indent, "Pointer", phase, var, start_offset);
2561 else
2562 print_phase_function(file, indent, array_type, phase, var, start_offset);
2563 }
2564 }
2565 else if (!is_ptr(var->type) && is_base_type(rtype))
2566 {
2567 print_phase_basetype(file, indent, phase, pass, var, var->name);
2568 }
2569 else if (!is_ptr(var->type))
2570 {
2571 switch (rtype)
2572 {
2573 case RPC_FC_STRUCT:
2574 case RPC_FC_PSTRUCT:
2575 print_phase_function(file, indent, "SimpleStruct", phase, var, start_offset);
2576 break;
2577 case RPC_FC_CSTRUCT:
2578 case RPC_FC_CPSTRUCT:
2579 print_phase_function(file, indent, "ConformantStruct", phase, var, start_offset);
2580 break;
2581 case RPC_FC_CVSTRUCT:
2582 print_phase_function(file, indent, "ConformantVaryingStruct", phase, var, start_offset);
2583 break;
2584 case RPC_FC_BOGUS_STRUCT:
2585 print_phase_function(file, indent, "ComplexStruct", phase, var, start_offset);
2586 break;
2587 case RPC_FC_RP:
2588 if (is_base_type( var->type->ref->type ))
2589 {
2590 print_phase_basetype(file, indent, phase, pass, var, var->name);
2591 }
2592 else if (var->type->ref->type == RPC_FC_STRUCT)
2593 {
2594 if (phase != PHASE_BUFFERSIZE && phase != PHASE_FREE)
2595 print_phase_function(file, indent, "SimpleStruct", phase, var, start_offset + 4);
2596 }
2597 else
2598 {
2599 const var_t *iid;
2600 if ((iid = get_attrp( var->attrs, ATTR_IIDIS )))
2601 print_file( file, indent, "_StubMsg.MaxCount = (unsigned long)%s;\n", iid->name );
2602 print_phase_function(file, indent, "Pointer", phase, var, start_offset);
2603 }
2604 break;
2605 default:
2606 error("write_remoting_arguments: Unsupported type: %s (0x%02x)\n", var->name, rtype);
2607 }
2608 }
2609 else
2610 {
2611 if (last_ptr(var->type) && (pointer_type == RPC_FC_RP) && is_base_type(rtype))
2612 {
2613 print_phase_basetype(file, indent, phase, pass, var, var->name);
2614 }
2615 else if (last_ptr(var->type) && (pointer_type == RPC_FC_RP) && (rtype == RPC_FC_STRUCT))
2616 {
2617 if (phase != PHASE_BUFFERSIZE && phase != PHASE_FREE)
2618 print_phase_function(file, indent, "SimpleStruct", phase, var, start_offset + 4);
2619 }
2620 else
2621 {
2622 const var_t *iid;
2623 if ((iid = get_attrp( var->attrs, ATTR_IIDIS )))
2624 print_file( file, indent, "_StubMsg.MaxCount = (unsigned long)%s;\n", iid->name );
2625 print_phase_function(file, indent, "Pointer", phase, var, start_offset);
2626 }
2627 }
2628 fprintf(file, "\n");
2629 }
2630 }
2631
2632
2633 size_t get_size_procformatstring_var(const var_t *var)
2634 {
2635 return write_procformatstring_var(NULL, 0, var, FALSE);
2636 }
2637
2638
2639 size_t get_size_procformatstring_func(const func_t *func)
2640 {
2641 const var_t *var;
2642 size_t size = 0;
2643
2644 /* argument list size */
2645 if (func->args)
2646 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2647 size += get_size_procformatstring_var(var);
2648
2649 /* return value size */
2650 if (is_void(func->def->type))
2651 size += 2; /* FC_END and FC_PAD */
2652 else
2653 size += get_size_procformatstring_var(func->def);
2654
2655 return size;
2656 }
2657
2658 size_t get_size_procformatstring(const ifref_list_t *ifaces, int for_objects)
2659 {
2660 const ifref_t *iface;
2661 size_t size = 1;
2662 const func_t *func;
2663
2664 if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, const ifref_t, entry )
2665 {
2666 if (for_objects != is_object(iface->iface->attrs) || is_local(iface->iface->attrs))
2667 continue;
2668
2669 if (iface->iface->funcs)
2670 LIST_FOR_EACH_ENTRY( func, iface->iface->funcs, const func_t, entry )
2671 if (!is_local(func->def->attrs))
2672 size += get_size_procformatstring_func( func );
2673 }
2674 return size;
2675 }
2676
2677 size_t get_size_typeformatstring(const ifref_list_t *ifaces, int for_objects)
2678 {
2679 set_all_tfswrite(ifaces, FALSE);
2680 return process_tfs(NULL, ifaces, for_objects);
2681 }
2682
2683 static void write_struct_expr(FILE *h, const expr_t *e, int brackets,
2684 const var_list_t *fields, const char *structvar)
2685 {
2686 switch (e->type) {
2687 case EXPR_VOID:
2688 break;
2689 case EXPR_NUM:
2690 fprintf(h, "%lu", e->u.lval);
2691 break;
2692 case EXPR_HEXNUM:
2693 fprintf(h, "0x%lx", e->u.lval);
2694 break;
2695 case EXPR_DOUBLE:
2696 fprintf(h, "%#.15g", e->u.dval);
2697 break;
2698 case EXPR_TRUEFALSE:
2699 if (e->u.lval == 0)
2700 fprintf(h, "FALSE");
2701 else
2702 fprintf(h, "TRUE");
2703 break;
2704 case EXPR_IDENTIFIER:
2705 {
2706 const var_t *field;
2707 LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
2708 if (!strcmp(e->u.sval, field->name))
2709 {
2710 fprintf(h, "%s->%s", structvar, e->u.sval);
2711 break;
2712 }
2713
2714 if (&field->entry == fields) error("no field found for identifier %s\n", e->u.sval);
2715 break;
2716 }
2717 case EXPR_NEG:
2718 fprintf(h, "-");
2719 write_struct_expr(h, e->ref, 1, fields, structvar);
2720 break;
2721 case EXPR_NOT:
2722 fprintf(h, "~");
2723 write_struct_expr(h, e->ref, 1, fields, structvar);
2724 break;
2725 case EXPR_PPTR:
2726 fprintf(h, "*");
2727 write_struct_expr(h, e->ref, 1, fields, structvar);
2728 break;
2729 case EXPR_CAST:
2730 fprintf(h, "(");
2731 write_type(h, e->u.tref, FALSE, NULL);
2732 fprintf(h, ")");
2733 write_struct_expr(h, e->ref, 1, fields, structvar);
2734 break;
2735 case EXPR_SIZEOF:
2736 fprintf(h, "sizeof(");
2737 write_type(h, e->u.tref, FALSE, NULL);
2738 fprintf(h, ")");
2739 break;
2740 case EXPR_SHL:
2741 case EXPR_SHR:
2742 case EXPR_MUL:
2743 case EXPR_DIV:
2744 case EXPR_ADD:
2745 case EXPR_SUB:
2746 case EXPR_AND:
2747 case EXPR_OR:
2748 if (brackets) fprintf(h, "(");
2749 write_struct_expr(h, e->ref, 1, fields, structvar);
2750 switch (e->type) {
2751 case EXPR_SHL: fprintf(h, " << "); break;
2752 case EXPR_SHR: fprintf(h, " >> "); break;
2753 case EXPR_MUL: fprintf(h, " * "); break;
2754 case EXPR_DIV: fprintf(h, " / "); break;
2755 case EXPR_ADD: fprintf(h, " + "); break;
2756 case EXPR_SUB: fprintf(h, " - "); break;
2757 case EXPR_AND: fprintf(h, " & "); break;
2758 case EXPR_OR: fprintf(h, " | "); break;
2759 default: break;
2760 }
2761 write_struct_expr(h, e->u.ext, 1, fields, structvar);
2762 if (brackets) fprintf(h, ")");
2763 break;
2764 case EXPR_COND:
2765 if (brackets) fprintf(h, "(");
2766 write_struct_expr(h, e->ref, 1, fields, structvar);
2767 fprintf(h, " ? ");
2768 write_struct_expr(h, e->u.ext, 1, fields, structvar);
2769 fprintf(h, " : ");
2770 write_struct_expr(h, e->ext2, 1, fields, structvar);
2771 if (brackets) fprintf(h, ")");
2772 break;
2773 }
2774 }
2775
2776
2777 void declare_stub_args( FILE *file, int indent, const func_t *func )
2778 {
2779 int in_attr, out_attr;
2780 int i = 0;
2781 const var_t *def = func->def;
2782 const var_t *var;
2783
2784 /* declare return value '_RetVal' */
2785 if (!is_void(def->type))
2786 {
2787 print_file(file, indent, "");
2788 write_type_left(file, def->type);
2789 fprintf(file, " _RetVal;\n");
2790 }
2791
2792 if (!func->args)
2793 return;
2794
2795 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2796 {
2797 int is_string = is_attr(var->attrs, ATTR_STRING);
2798
2799 in_attr = is_attr(var->attrs, ATTR_IN);
2800 out_attr = is_attr(var->attrs, ATTR_OUT);
2801 if (!out_attr && !in_attr)
2802 in_attr = 1;
2803
2804 if (!in_attr && !var->type->size_is && !is_string)
2805 {
2806 print_file(file, indent, "");
2807 write_type(file, var->type->ref, FALSE, "_W%u", i++);
2808 fprintf(file, ";\n");
2809 }
2810
2811 print_file(file, indent, "");
2812 write_type_left(file, var->type);
2813 fprintf(file, " ");
2814 if (var->type->declarray) {
2815 fprintf(file, "( *");
2816 write_name(file, var);
2817 fprintf(file, " )");
2818 } else
2819 write_name(file, var);
2820 write_type_right(file, var->type, FALSE);
2821 fprintf(file, ";\n");
2822
2823 if (decl_indirect(var->type))
2824 print_file(file, indent, "void *_p_%s = &%s;\n",
2825 var->name, var->name);
2826 }
2827 }
2828
2829
2830 void assign_stub_out_args( FILE *file, int indent, const func_t *func )
2831 {
2832 int in_attr, out_attr;
2833 int i = 0, sep = 0;
2834 const var_t *var;
2835
2836 if (!func->args)
2837 return;
2838
2839 LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
2840 {
2841 int is_string = is_attr(var->attrs, ATTR_STRING);
2842 in_attr = is_attr(var->attrs, ATTR_IN);
2843 out_attr = is_attr(var->attrs, ATTR_OUT);
2844 if (!out_attr && !in_attr)
2845 in_attr = 1;
2846
2847 if (!in_attr)
2848 {
2849 print_file(file, indent, "");
2850 write_name(file, var);
2851
2852 if (var->type->size_is)
2853 {
2854 unsigned int size, align = 0;
2855 type_t *type = var->type;
2856
2857 fprintf(file, " = NdrAllocate(&_StubMsg, ");
2858 for ( ; type->size_is ; type = type->ref)
2859 {
2860 write_expr(file, type->size_is, TRUE);
2861 fprintf(file, " * ");
2862 }
2863 size = type_memsize(type, &align);
2864 fprintf(file, "%u);\n", size);
2865 }
2866 else if (!is_string)
2867 {
2868 fprintf(file, " = &_W%u;\n", i);
2869 if (is_ptr(var->type) && !last_ptr(var->type))
2870 print_file(file, indent, "_W%u = 0;\n", i);
2871 i++;
2872 }
2873
2874 sep = 1;
2875 }
2876 }
2877 if (sep)
2878 fprintf(file, "\n");
2879 }
2880
2881
2882 int write_expr_eval_routines(FILE *file, const char *iface)
2883 {
2884 int result = 0;
2885 struct expr_eval_routine *eval;
2886 unsigned short callback_offset = 0;
2887
2888 LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
2889 {
2890 int indent = 0;
2891 result = 1;
2892 print_file(file, indent, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
2893 iface, eval->structure->name, callback_offset);
2894 print_file(file, indent, "{\n");
2895 indent++;
2896 print_file(file, indent, "struct %s *" STRUCT_EXPR_EVAL_VAR " = (struct %s *)(pStubMsg->StackTop - %u);\n",
2897 eval->structure->name, eval->structure->name, eval->structure_size);
2898 fprintf(file, "\n");
2899 print_file(file, indent, "pStubMsg->Offset = 0;\n"); /* FIXME */
2900 print_file(file, indent, "pStubMsg->MaxCount = (unsigned long)");
2901 write_struct_expr(file, eval->expr, 1, eval->structure->fields, STRUCT_EXPR_EVAL_VAR);
2902 fprintf(file, ";\n");
2903 indent--;
2904 print_file(file, indent, "}\n\n");
2905 callback_offset++;
2906 }
2907 return result;
2908 }
2909
2910 void write_expr_eval_routine_list(FILE *file, const char *iface)
2911 {
2912 struct expr_eval_routine *eval;
2913 struct expr_eval_routine *cursor;
2914 unsigned short callback_offset = 0;
2915
2916 fprintf(file, "static const EXPR_EVAL ExprEvalRoutines[] =\n");
2917 fprintf(file, "{\n");
2918
2919 LIST_FOR_EACH_ENTRY_SAFE(eval, cursor, &expr_eval_routines, struct expr_eval_routine, entry)
2920 {
2921 print_file(file, 1, "%s_%sExprEval_%04u,\n",
2922 iface, eval->structure->name, callback_offset);
2923
2924 callback_offset++;
2925 list_remove(&eval->entry);
2926 free(eval);
2927 }
2928
2929 fprintf(file, "};\n\n");
2930 }
2931
2932 void write_user_quad_list(FILE *file)
2933 {
2934 user_type_t *ut;
2935
2936 if (list_empty(&user_type_list))
2937 return;
2938
2939 fprintf(file, "static const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[] =\n");
2940 fprintf(file, "{\n");
2941 LIST_FOR_EACH_ENTRY(ut, &user_type_list, user_type_t, entry)
2942 {
2943 const char *sep = &ut->entry == list_tail(&user_type_list) ? "" : ",";
2944 print_file(file, 1, "{\n");
2945 print_file(file, 2, "(USER_MARSHAL_SIZING_ROUTINE)%s_UserSize,\n", ut->name);
2946 print_file(file, 2, "(USER_MARSHAL_MARSHALLING_ROUTINE)%s_UserMarshal,\n", ut->name);
2947 print_file(file, 2, "(USER_MARSHAL_UNMARSHALLING_ROUTINE)%s_UserUnmarshal,\n", ut->name);
2948 print_file(file, 2, "(USER_MARSHAL_FREEING_ROUTINE)%s_UserFree\n", ut->name);
2949 print_file(file, 1, "}%s\n", sep);
2950 }
2951 fprintf(file, "};\n\n");
2952 }
2953
2954 void write_endpoints( FILE *f, const char *prefix, const str_list_t *list )
2955 {
2956 const struct str_list_entry_t *endpoint;
2957 const char *p;
2958
2959 /* this should be an array of RPC_PROTSEQ_ENDPOINT but we want const strings */
2960 print_file( f, 0, "static const unsigned char * %s__RpcProtseqEndpoint[][2] =\n{\n", prefix );
2961 LIST_FOR_EACH_ENTRY( endpoint, list, const struct str_list_entry_t, entry )
2962 {
2963 print_file( f, 1, "{ (const unsigned char *)\"" );
2964 for (p = endpoint->str; *p && *p != ':'; p++)
2965 {
2966 if (*p == '"' || *p == '\\') fputc( '\\', f );
2967 fputc( *p, f );
2968 }
2969 if (!*p) goto error;
2970 if (p[1] != '[') goto error;
2971
2972 fprintf( f, "\", (const unsigned char *)\"" );
2973 for (p += 2; *p && *p != ']'; p++)
2974 {
2975 if (*p == '"' || *p == '\\') fputc( '\\', f );
2976 fputc( *p, f );
2977 }
2978 if (*p != ']') goto error;
2979 fprintf( f, "\" },\n" );
2980 }
2981 print_file( f, 0, "};\n\n" );
2982 return;
2983
2984 error:
2985 error("Invalid endpoint syntax '%s'\n", endpoint->str);
2986 }
Maarten's multimedia branch