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