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