reactos/tools/widl/typegen.c

   1 /*
   2  * Format String Generator for IDL Compiler
   3  *
   4  * Copyright 2005-2006 Eric Kohl
   5  * Copyright 2005-2006 Robert Shearman
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #ifdef HAVE_UNISTD_H
  28 # include <unistd.h>
  29 #endif
  30 #include <string.h>
  31 #include <assert.h>
  32 #include <ctype.h>
  33 #include <limits.h>
  34
  35 #include "widl.h"
  36 #include "utils.h"
  37 #include "parser.h"
  38 #include "header.h"
  39 #include "typetree.h"
  40
  41 #include "typegen.h"
  42 #include "expr.h"
  43
  44 /* round size up to multiple of alignment */
  45 #define ROUND_SIZE(size, alignment) (((size) + ((alignment) - 1)) & ~((alignment) - 1))
  46 /* value to add on to round size up to a multiple of alignment */
  47 #define ROUNDING(size, alignment) (((alignment) - 1) - (((size) + ((alignment) - 1)) & ((alignment) - 1)))
  48
  49 static const var_t *current_func;
  50 static const type_t *current_structure;
  51 static const type_t *current_iface;
  52
  53 static struct list expr_eval_routines = LIST_INIT(expr_eval_routines);
  54 struct expr_eval_routine
  55 {
  56     struct list entry;
  57     const type_t *structure;
  58     unsigned int baseoff;
  59     const expr_t *expr;
  60 };
  61
  62 enum type_context
  63 {
  64     TYPE_CONTEXT_TOPLEVELPARAM,
  65     TYPE_CONTEXT_PARAM,
  66     TYPE_CONTEXT_CONTAINER,
  67     TYPE_CONTEXT_CONTAINER_NO_POINTERS,
  68 };
  69
  70 static unsigned int field_memsize(const type_t *type, unsigned int *offset);
  71 static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align);
  72 static unsigned int write_struct_tfs(FILE *file, type_t *type, const char *name, unsigned int *tfsoff);
  73 static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
  74                                 const char *name, int write_ptr, unsigned int *tfsoff);
  75 static const var_t *find_array_or_string_in_struct(const type_t *type);
  76 static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
  77                                type_t *type, int toplevel_param,
  78                                const char *name, unsigned int *typestring_offset);
  79
  80 static const char *string_of_type(unsigned char type)
  81 {
  82     switch (type)
  83     {
  84     case RPC_FC_BYTE: return "FC_BYTE";
  85     case RPC_FC_CHAR: return "FC_CHAR";
  86     case RPC_FC_SMALL: return "FC_SMALL";
  87     case RPC_FC_USMALL: return "FC_USMALL";
  88     case RPC_FC_WCHAR: return "FC_WCHAR";
  89     case RPC_FC_SHORT: return "FC_SHORT";
  90     case RPC_FC_USHORT: return "FC_USHORT";
  91     case RPC_FC_LONG: return "FC_LONG";
  92     case RPC_FC_ULONG: return "FC_ULONG";
  93     case RPC_FC_FLOAT: return "FC_FLOAT";
  94     case RPC_FC_HYPER: return "FC_HYPER";
  95     case RPC_FC_DOUBLE: return "FC_DOUBLE";
  96     case RPC_FC_ENUM16: return "FC_ENUM16";
  97     case RPC_FC_ENUM32: return "FC_ENUM32";
  98     case RPC_FC_IGNORE: return "FC_IGNORE";
  99     case RPC_FC_ERROR_STATUS_T: return "FC_ERROR_STATUS_T";
 100     case RPC_FC_RP: return "FC_RP";
 101     case RPC_FC_UP: return "FC_UP";
 102     case RPC_FC_OP: return "FC_OP";
 103     case RPC_FC_FP: return "FC_FP";
 104     case RPC_FC_ENCAPSULATED_UNION: return "FC_ENCAPSULATED_UNION";
 105     case RPC_FC_NON_ENCAPSULATED_UNION: return "FC_NON_ENCAPSULATED_UNION";
 106     case RPC_FC_STRUCT: return "FC_STRUCT";
 107     case RPC_FC_PSTRUCT: return "FC_PSTRUCT";
 108     case RPC_FC_CSTRUCT: return "FC_CSTRUCT";
 109     case RPC_FC_CPSTRUCT: return "FC_CPSTRUCT";
 110     case RPC_FC_CVSTRUCT: return "FC_CVSTRUCT";
 111     case RPC_FC_BOGUS_STRUCT: return "FC_BOGUS_STRUCT";
 112     case RPC_FC_SMFARRAY: return "FC_SMFARRAY";
 113     case RPC_FC_LGFARRAY: return "FC_LGFARRAY";
 114     case RPC_FC_SMVARRAY: return "FC_SMVARRAY";
 115     case RPC_FC_LGVARRAY: return "FC_LGVARRAY";
 116     case RPC_FC_CARRAY: return "FC_CARRAY";
 117     case RPC_FC_CVARRAY: return "FC_CVARRAY";
 118     case RPC_FC_BOGUS_ARRAY: return "FC_BOGUS_ARRAY";
 119     case RPC_FC_ALIGNM2: return "FC_ALIGNM2";
 120     case RPC_FC_ALIGNM4: return "FC_ALIGNM4";
 121     case RPC_FC_ALIGNM8: return "FC_ALIGNM8";
 122     case RPC_FC_POINTER: return "FC_POINTER";
 123     case RPC_FC_C_CSTRING: return "FC_C_CSTRING";
 124     case RPC_FC_C_WSTRING: return "FC_C_WSTRING";
 125     case RPC_FC_CSTRING: return "FC_CSTRING";
 126     case RPC_FC_WSTRING: return "FC_WSTRING";
 127     case RPC_FC_INT3264: return "FC_INT3264";
 128     case RPC_FC_UINT3264: return "FC_UINT3264";
 129     default:
 130         error("string_of_type: unknown type 0x%02x\n", type);
 131         return NULL;
 132     }
 133 }
 134
 135 static void *get_aliaschain_attrp(const type_t *type, enum attr_type attr)
 136 {
 137     const type_t *t = type;
 138     for (;;)
 139     {
 140         if (is_attr(t->attrs, attr))
 141             return get_attrp(t->attrs, attr);
 142         else if (type_is_alias(t))
 143             t = type_alias_get_aliasee(t);
 144         else return NULL;
 145     }
 146 }
 147
 148 unsigned char get_basic_fc(const type_t *type)
 149 {
 150     int sign = type_basic_get_sign(type);
 151     switch (type_basic_get_type(type))
 152     {
 153     case TYPE_BASIC_INT8: return (sign <= 0 ? RPC_FC_SMALL : RPC_FC_USMALL);
 154     case TYPE_BASIC_INT16: return (sign <= 0 ? RPC_FC_SHORT : RPC_FC_USHORT);
 155     case TYPE_BASIC_INT32: return (sign <= 0 ? RPC_FC_LONG : RPC_FC_ULONG);
 156     case TYPE_BASIC_INT64: return RPC_FC_HYPER;
 157     case TYPE_BASIC_INT: return (sign <= 0 ? RPC_FC_LONG : RPC_FC_ULONG);
 158     case TYPE_BASIC_INT3264: return (sign <= 0 ? RPC_FC_INT3264 : RPC_FC_UINT3264);
 159     case TYPE_BASIC_BYTE: return RPC_FC_BYTE;
 160     case TYPE_BASIC_CHAR: return RPC_FC_CHAR;
 161     case TYPE_BASIC_WCHAR: return RPC_FC_WCHAR;
 162     case TYPE_BASIC_HYPER: return RPC_FC_HYPER;
 163     case TYPE_BASIC_FLOAT: return RPC_FC_FLOAT;
 164     case TYPE_BASIC_DOUBLE: return RPC_FC_DOUBLE;
 165     case TYPE_BASIC_ERROR_STATUS_T: return RPC_FC_ERROR_STATUS_T;
 166     case TYPE_BASIC_HANDLE: return RPC_FC_BIND_PRIMITIVE;
 167     }
 168     return 0;
 169 }
 170
 171 static inline unsigned int clamp_align(unsigned int align)
 172 {
 173     unsigned int packing = (pointer_size == 4) ? win32_packing : win64_packing;
 174     if(align > packing) align = packing;
 175     return align;
 176 }
 177
 178 unsigned char get_pointer_fc(const type_t *type, const attr_list_t *attrs, int toplevel_param)
 179 {
 180     const type_t *t;
 181     int pointer_type;
 182
 183     assert(is_ptr(type) || is_array(type));
 184
 185     pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
 186     if (pointer_type)
 187         return pointer_type;
 188
 189     for (t = type; type_is_alias(t); t = type_alias_get_aliasee(t))
 190     {
 191         pointer_type = get_attrv(t->attrs, ATTR_POINTERTYPE);
 192         if (pointer_type)
 193             return pointer_type;
 194     }
 195
 196     if (toplevel_param)
 197         return RPC_FC_RP;
 198     else if (is_ptr(type))
 199         return type_pointer_get_default_fc(type);
 200     else
 201         return type_array_get_ptr_default_fc(type);
 202 }
 203
 204 static unsigned char get_enum_fc(const type_t *type)
 205 {
 206     assert(type_get_type(type) == TYPE_ENUM);
 207     if (is_aliaschain_attr(type, ATTR_V1ENUM))
 208         return RPC_FC_ENUM32;
 209     else
 210         return RPC_FC_ENUM16;
 211 }
 212
 213 static type_t *get_user_type(const type_t *t, const char **pname)
 214 {
 215     for (;;)
 216     {
 217         type_t *ut = get_attrp(t->attrs, ATTR_WIREMARSHAL);
 218         if (ut)
 219         {
 220             if (pname)
 221                 *pname = t->name;
 222             return ut;
 223         }
 224
 225         if (type_is_alias(t))
 226             t = type_alias_get_aliasee(t);
 227         else
 228             return NULL;
 229     }
 230 }
 231
 232 static int is_user_type(const type_t *t)
 233 {
 234     return get_user_type(t, NULL) != NULL;
 235 }
 236
 237 enum typegen_type typegen_detect_type(const type_t *type, const attr_list_t *attrs, unsigned int flags)
 238 {
 239     if (is_user_type(type))
 240         return TGT_USER_TYPE;
 241
 242     if (is_aliaschain_attr(type, ATTR_CONTEXTHANDLE))
 243         return TGT_CTXT_HANDLE;
 244
 245     if (!(flags & TDT_IGNORE_STRINGS) && is_string_type(attrs, type))
 246         return TGT_STRING;
 247
 248     switch (type_get_type(type))
 249     {
 250     case TYPE_BASIC:
 251         if (!(flags & TDT_IGNORE_RANGES) &&
 252             (is_attr(attrs, ATTR_RANGE) || is_aliaschain_attr(type, ATTR_RANGE)))
 253             return TGT_RANGE;
 254         return TGT_BASIC;
 255     case TYPE_ENUM:
 256         if (!(flags & TDT_IGNORE_RANGES) &&
 257             (is_attr(attrs, ATTR_RANGE) || is_aliaschain_attr(type, ATTR_RANGE)))
 258             return TGT_RANGE;
 259         return TGT_ENUM;
 260     case TYPE_POINTER:
 261         if (type_get_type(type_pointer_get_ref(type)) == TYPE_INTERFACE ||
 262             (type_get_type(type_pointer_get_ref(type)) == TYPE_VOID && is_attr(attrs, ATTR_IIDIS)))
 263             return TGT_IFACE_POINTER;
 264         else if (is_aliaschain_attr(type_pointer_get_ref(type), ATTR_CONTEXTHANDLE))
 265             return TGT_CTXT_HANDLE_POINTER;
 266         else
 267             return TGT_POINTER;
 268     case TYPE_STRUCT:
 269         return TGT_STRUCT;
 270     case TYPE_ENCAPSULATED_UNION:
 271     case TYPE_UNION:
 272         return TGT_UNION;
 273     case TYPE_ARRAY:
 274         return TGT_ARRAY;
 275     case TYPE_FUNCTION:
 276     case TYPE_COCLASS:
 277     case TYPE_INTERFACE:
 278     case TYPE_MODULE:
 279     case TYPE_VOID:
 280     case TYPE_ALIAS:
 281     case TYPE_BITFIELD:
 282         break;
 283     }
 284     return TGT_INVALID;
 285 }
 286
 287 static int get_padding(const var_list_t *fields)
 288 {
 289     unsigned short offset = 0;
 290     unsigned int salign = 1;
 291     const var_t *f;
 292
 293     if (!fields)
 294         return 0;
 295
 296     LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry)
 297     {
 298         type_t *ft = f->type;
 299         unsigned int align = 0;
 300         unsigned int size = type_memsize(ft, &align);
 301         align = clamp_align(align);
 302         if (align > salign) salign = align;
 303         offset = ROUND_SIZE(offset, align);
 304         offset += size;
 305     }
 306
 307     return ROUNDING(offset, salign);
 308 }
 309
 310 unsigned char get_struct_fc(const type_t *type)
 311 {
 312   int has_pointer = 0;
 313   int has_conformance = 0;
 314   int has_variance = 0;
 315   var_t *field;
 316   var_list_t *fields;
 317
 318   fields = type_struct_get_fields(type);
 319
 320   if (get_padding(fields))
 321     return RPC_FC_BOGUS_STRUCT;
 322
 323   if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry )
 324   {
 325     type_t *t = field->type;
 326     enum typegen_type typegen_type;
 327
 328     typegen_type = typegen_detect_type(t, field->attrs, TDT_IGNORE_STRINGS);
 329
 330     if (typegen_type == TGT_ARRAY && !type_array_is_decl_as_ptr(t))
 331     {
 332         if (is_string_type(field->attrs, field->type))
 333         {
 334             if (is_conformant_array(t))
 335                 has_conformance = 1;
 336             has_variance = 1;
 337             continue;
 338         }
 339
 340         if (is_array(type_array_get_element(field->type)))
 341             return RPC_FC_BOGUS_STRUCT;
 342
 343         if (type_array_has_conformance(field->type))
 344         {
 345             has_conformance = 1;
 346             if (list_next(fields, &field->entry))
 347                 error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n",
 348                         field->name);
 349         }
 350         if (type_array_has_variance(t))
 351             has_variance = 1;
 352
 353         t = type_array_get_element(t);
 354         typegen_type = typegen_detect_type(t, field->attrs, TDT_IGNORE_STRINGS);
 355     }
 356
 357     switch (typegen_type)
 358     {
 359     case TGT_USER_TYPE:
 360     case TGT_IFACE_POINTER:
 361         return RPC_FC_BOGUS_STRUCT;
 362     case TGT_BASIC:
 363         if (type_basic_get_type(t) == TYPE_BASIC_INT3264 && pointer_size != 4)
 364             return RPC_FC_BOGUS_STRUCT;
 365         break;
 366     case TGT_ENUM:
 367         if (get_enum_fc(t) == RPC_FC_ENUM16)
 368             return RPC_FC_BOGUS_STRUCT;
 369         break;
 370     case TGT_POINTER:
 371     case TGT_ARRAY:
 372         if (get_pointer_fc(t, field->attrs, FALSE) == RPC_FC_RP || pointer_size != 4)
 373             return RPC_FC_BOGUS_STRUCT;
 374         has_pointer = 1;
 375         break;
 376     case TGT_UNION:
 377         return RPC_FC_BOGUS_STRUCT;
 378     case TGT_STRUCT:
 379     {
 380         unsigned char fc = get_struct_fc(t);
 381         switch (fc)
 382         {
 383         case RPC_FC_STRUCT:
 384             break;
 385         case RPC_FC_CVSTRUCT:
 386             has_conformance = 1;
 387             has_variance = 1;
 388             has_pointer = 1;
 389             break;
 390
 391         case RPC_FC_CPSTRUCT:
 392             has_conformance = 1;
 393             if (list_next( fields, &field->entry ))
 394                 error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n",
 395                         field->name);
 396             has_pointer = 1;
 397             break;
 398
 399         case RPC_FC_CSTRUCT:
 400             has_conformance = 1;
 401             if (list_next( fields, &field->entry ))
 402                 error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n",
 403                       field->name);
 404             break;
 405
 406         case RPC_FC_PSTRUCT:
 407             has_pointer = 1;
 408             break;
 409
 410         default:
 411             error_loc("Unknown struct member %s with type (0x%02x)\n", field->name, fc);
 412             /* fallthru - treat it as complex */
 413
 414         /* as soon as we see one of these these members, it's bogus... */
 415         case RPC_FC_BOGUS_STRUCT:
 416             return RPC_FC_BOGUS_STRUCT;
 417         }
 418         break;
 419     }
 420     case TGT_RANGE:
 421         return RPC_FC_BOGUS_STRUCT;
 422     case TGT_STRING:
 423         /* shouldn't get here because of TDT_IGNORE_STRINGS above. fall through */
 424     case TGT_INVALID:
 425     case TGT_CTXT_HANDLE:
 426     case TGT_CTXT_HANDLE_POINTER:
 427         /* checking after parsing should mean that we don't get here. if we do,
 428          * it's a checker bug */
 429         assert(0);
 430     }
 431   }
 432
 433   if( has_variance )
 434   {
 435     if ( has_conformance )
 436       return RPC_FC_CVSTRUCT;
 437     else
 438       return RPC_FC_BOGUS_STRUCT;
 439   }
 440   if( has_conformance && has_pointer )
 441     return RPC_FC_CPSTRUCT;
 442   if( has_conformance )
 443     return RPC_FC_CSTRUCT;
 444   if( has_pointer )
 445     return RPC_FC_PSTRUCT;
 446   return RPC_FC_STRUCT;
 447 }
 448
 449 static unsigned char get_array_fc(const type_t *type)
 450 {
 451     unsigned char fc;
 452     const expr_t *size_is;
 453     const type_t *elem_type;
 454
 455     elem_type = type_array_get_element(type);
 456     size_is = type_array_get_conformance(type);
 457
 458     if (!size_is)
 459     {
 460         unsigned int align = 0;
 461         unsigned int size = type_memsize(elem_type, &align);
 462         if (size * type_array_get_dim(type) > 0xffffuL)
 463             fc = RPC_FC_LGFARRAY;
 464         else
 465             fc = RPC_FC_SMFARRAY;
 466     }
 467     else
 468         fc = RPC_FC_CARRAY;
 469
 470     if (type_array_has_variance(type))
 471     {
 472         if (fc == RPC_FC_SMFARRAY)
 473             fc = RPC_FC_SMVARRAY;
 474         else if (fc == RPC_FC_LGFARRAY)
 475             fc = RPC_FC_LGVARRAY;
 476         else if (fc == RPC_FC_CARRAY)
 477             fc = RPC_FC_CVARRAY;
 478     }
 479
 480     switch (typegen_detect_type(elem_type, NULL, TDT_IGNORE_STRINGS))
 481     {
 482     case TGT_USER_TYPE:
 483         fc = RPC_FC_BOGUS_ARRAY;
 484         break;
 485     case TGT_BASIC:
 486         if (type_basic_get_type(elem_type) == TYPE_BASIC_INT3264 &&
 487             pointer_size != 4)
 488             fc = RPC_FC_BOGUS_ARRAY;
 489         break;
 490     case TGT_STRUCT:
 491         switch (get_struct_fc(elem_type))
 492         {
 493         case RPC_FC_BOGUS_STRUCT:
 494             fc = RPC_FC_BOGUS_ARRAY;
 495             break;
 496         }
 497         break;
 498     case TGT_ENUM:
 499         /* is 16-bit enum - if so, wire size differs from mem size and so
 500          * the array cannot be block copied, which means the array is complex */
 501         if (get_enum_fc(elem_type) == RPC_FC_ENUM16)
 502             fc = RPC_FC_BOGUS_ARRAY;
 503         break;
 504     case TGT_UNION:
 505     case TGT_IFACE_POINTER:
 506         fc = RPC_FC_BOGUS_ARRAY;
 507         break;
 508     case TGT_POINTER:
 509         /* ref pointers cannot just be block copied. unique pointers to
 510          * interfaces need special treatment. either case means the array is
 511          * complex */
 512         if (get_pointer_fc(elem_type, NULL, FALSE) == RPC_FC_RP || pointer_size != 4)
 513             fc = RPC_FC_BOGUS_ARRAY;
 514         break;
 515     case TGT_RANGE:
 516         fc = RPC_FC_BOGUS_ARRAY;
 517         break;
 518     case TGT_CTXT_HANDLE:
 519     case TGT_CTXT_HANDLE_POINTER:
 520     case TGT_STRING:
 521     case TGT_INVALID:
 522     case TGT_ARRAY:
 523         /* nothing to do for everything else */
 524         break;
 525     }
 526
 527     return fc;
 528 }
 529
 530 static int is_non_complex_struct(const type_t *type)
 531 {
 532     return (type_get_type(type) == TYPE_STRUCT &&
 533             get_struct_fc(type) != RPC_FC_BOGUS_STRUCT);
 534 }
 535
 536 static int type_has_pointers(const type_t *type)
 537 {
 538     switch (typegen_detect_type(type, NULL, TDT_IGNORE_STRINGS))
 539     {
 540     case TGT_USER_TYPE:
 541         return FALSE;
 542     case TGT_POINTER:
 543         return TRUE;
 544     case TGT_ARRAY:
 545         return type_array_is_decl_as_ptr(type) || type_has_pointers(type_array_get_element(type));
 546     case TGT_STRUCT:
 547     {
 548         var_list_t *fields = type_struct_get_fields(type);
 549         const var_t *field;
 550         if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
 551         {
 552             if (type_has_pointers(field->type))
 553                 return TRUE;
 554         }
 555         break;
 556     }
 557     case TGT_UNION:
 558     {
 559         var_list_t *fields;
 560         const var_t *field;
 561         fields = type_union_get_cases(type);
 562         if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
 563         {
 564             if (field->type && type_has_pointers(field->type))
 565                 return TRUE;
 566         }
 567         break;
 568     }
 569     case TGT_CTXT_HANDLE:
 570     case TGT_CTXT_HANDLE_POINTER:
 571     case TGT_STRING:
 572     case TGT_IFACE_POINTER:
 573     case TGT_BASIC:
 574     case TGT_ENUM:
 575     case TGT_RANGE:
 576     case TGT_INVALID:
 577         break;
 578     }
 579
 580     return FALSE;
 581 }
 582
 583 static int type_has_full_pointer(const type_t *type, const attr_list_t *attrs,
 584                                  int toplevel_param)
 585 {
 586     switch (typegen_detect_type(type, NULL, TDT_IGNORE_STRINGS))
 587     {
 588     case TGT_USER_TYPE:
 589         return FALSE;
 590     case TGT_POINTER:
 591         if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_FP)
 592             return TRUE;
 593         else
 594             return FALSE;
 595     case TGT_ARRAY:
 596         if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_FP)
 597             return TRUE;
 598         else
 599             return type_has_full_pointer(type_array_get_element(type), NULL, FALSE);
 600     case TGT_STRUCT:
 601     {
 602         var_list_t *fields = type_struct_get_fields(type);
 603         const var_t *field;
 604         if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
 605         {
 606             if (type_has_full_pointer(field->type, field->attrs, FALSE))
 607                 return TRUE;
 608         }
 609         break;
 610     }
 611     case TGT_UNION:
 612     {
 613         var_list_t *fields;
 614         const var_t *field;
 615         fields = type_union_get_cases(type);
 616         if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
 617         {
 618             if (field->type && type_has_full_pointer(field->type, field->attrs, FALSE))
 619                 return TRUE;
 620         }
 621         break;
 622     }
 623     case TGT_CTXT_HANDLE:
 624     case TGT_CTXT_HANDLE_POINTER:
 625     case TGT_STRING:
 626     case TGT_IFACE_POINTER:
 627     case TGT_BASIC:
 628     case TGT_ENUM:
 629     case TGT_RANGE:
 630     case TGT_INVALID:
 631         break;
 632     }
 633
 634     return FALSE;
 635 }
 636
 637 static unsigned short user_type_offset(const char *name)
 638 {
 639     user_type_t *ut;
 640     unsigned short off = 0;
 641     LIST_FOR_EACH_ENTRY(ut, &user_type_list, user_type_t, entry)
 642     {
 643         if (strcmp(name, ut->name) == 0)
 644             return off;
 645         ++off;
 646     }
 647     error("user_type_offset: couldn't find type (%s)\n", name);
 648     return 0;
 649 }
 650
 651 static void update_tfsoff(type_t *type, unsigned int offset, FILE *file)
 652 {
 653     type->typestring_offset = offset;
 654     if (file) type->tfswrite = FALSE;
 655 }
 656
 657 static void guard_rec(type_t *type)
 658 {
 659     /* types that contain references to themselves (like a linked list),
 660        need to be shielded from infinite recursion when writing embedded
 661        types  */
 662     if (type->typestring_offset)
 663         type->tfswrite = FALSE;
 664     else
 665         type->typestring_offset = 1;
 666 }
 667
 668 static int is_embedded_complex(const type_t *type)
 669 {
 670     switch (typegen_detect_type(type, NULL, TDT_ALL_TYPES))
 671     {
 672     case TGT_USER_TYPE:
 673     case TGT_STRUCT:
 674     case TGT_UNION:
 675     case TGT_ARRAY:
 676     case TGT_IFACE_POINTER:
 677         return TRUE;
 678     default:
 679         return FALSE;
 680     }
 681 }
 682
 683 static const char *get_context_handle_type_name(const type_t *type)
 684 {
 685     const type_t *t;
 686     for (t = type;
 687          is_ptr(t) || type_is_alias(t);
 688          t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t))
 689         if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
 690             return t->name;
 691     assert(0);
 692     return NULL;
 693 }
 694
 695 #define WRITE_FCTYPE(file, fctype, typestring_offset) \
 696     do { \
 697         if (file) \
 698             fprintf(file, "/* %2u */\n", typestring_offset); \
 699         print_file((file), 2, "0x%02x,    /* " #fctype " */\n", RPC_##fctype); \
 700     } \
 701     while (0)
 702
 703 static void print_file(FILE *file, int indent, const char *format, ...) __attribute__((format (printf, 3, 4)));
 704 static void print_file(FILE *file, int indent, const char *format, ...)
 705 {
 706     va_list va;
 707     va_start(va, format);
 708     print(file, indent, format, va);
 709     va_end(va);
 710 }
 711
 712 void print(FILE *file, int indent, const char *format, va_list va)
 713 {
 714     if (file)
 715     {
 716         if (format[0] != '\n')
 717             while (0 < indent--)
 718                 fprintf(file, "    ");
 719         vfprintf(file, format, va);
 720     }
 721 }
 722
 723
 724 static void write_var_init(FILE *file, int indent, const type_t *t, const char *n, const char *local_var_prefix)
 725 {
 726     if (decl_indirect(t))
 727     {
 728         print_file(file, indent, "MIDL_memset(&%s%s, 0, sizeof(%s%s));\n",
 729                    local_var_prefix, n, local_var_prefix, n);
 730         print_file(file, indent, "%s_p_%s = &%s%s;\n", local_var_prefix, n, local_var_prefix, n);
 731     }
 732     else if (is_ptr(t) || is_array(t))
 733         print_file(file, indent, "%s%s = 0;\n", local_var_prefix, n);
 734 }
 735
 736 void write_parameters_init(FILE *file, int indent, const var_t *func, const char *local_var_prefix)
 737 {
 738     const var_t *var;
 739
 740     if (!is_void(type_function_get_rettype(func->type)))
 741         write_var_init(file, indent, type_function_get_rettype(func->type), "_RetVal", local_var_prefix);
 742
 743     if (!type_get_function_args(func->type))
 744         return;
 745
 746     LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
 747         write_var_init(file, indent, var->type, var->name, local_var_prefix);
 748
 749     fprintf(file, "\n");
 750 }
 751
 752 static void write_formatdesc(FILE *f, int indent, const char *str)
 753 {
 754     print_file(f, indent, "typedef struct _MIDL_%s_FORMAT_STRING\n", str);
 755     print_file(f, indent, "{\n");
 756     print_file(f, indent + 1, "short Pad;\n");
 757     print_file(f, indent + 1, "unsigned char Format[%s_FORMAT_STRING_SIZE];\n", str);
 758     print_file(f, indent, "} MIDL_%s_FORMAT_STRING;\n", str);
 759     print_file(f, indent, "\n");
 760 }
 761
 762 void write_formatstringsdecl(FILE *f, int indent, const statement_list_t *stmts, type_pred_t pred)
 763 {
 764     clear_all_offsets();
 765
 766     print_file(f, indent, "#define TYPE_FORMAT_STRING_SIZE %d\n",
 767                get_size_typeformatstring(stmts, pred));
 768
 769     print_file(f, indent, "#define PROC_FORMAT_STRING_SIZE %d\n",
 770                get_size_procformatstring(stmts, pred));
 771
 772     fprintf(f, "\n");
 773     write_formatdesc(f, indent, "TYPE");
 774     write_formatdesc(f, indent, "PROC");
 775     fprintf(f, "\n");
 776     print_file(f, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;\n");
 777     print_file(f, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;\n");
 778     print_file(f, indent, "\n");
 779 }
 780
 781 int decl_indirect(const type_t *t)
 782 {
 783     if (is_user_type(t))
 784         return TRUE;
 785     return (type_get_type(t) != TYPE_BASIC &&
 786             type_get_type(t) != TYPE_ENUM &&
 787             type_get_type(t) != TYPE_POINTER &&
 788             type_get_type(t) != TYPE_ARRAY);
 789 }
 790
 791 static unsigned int write_procformatstring_type(FILE *file, int indent,
 792                                                 const char *name,
 793                                                 const type_t *type,
 794                                                 const attr_list_t *attrs,
 795                                                 int is_return)
 796 {
 797     unsigned int size;
 798
 799     int is_in = is_attr(attrs, ATTR_IN);
 800     int is_out = is_attr(attrs, ATTR_OUT);
 801
 802     if (!is_in && !is_out) is_in = TRUE;
 803
 804     if (type_get_type(type) == TYPE_BASIC ||
 805         type_get_type(type) == TYPE_ENUM)
 806     {
 807         unsigned char fc;
 808
 809         if (is_return)
 810             print_file(file, indent, "0x53,    /* FC_RETURN_PARAM_BASETYPE */\n");
 811         else
 812             print_file(file, indent, "0x4e,    /* FC_IN_PARAM_BASETYPE */\n");
 813
 814         if (type_get_type(type) == TYPE_ENUM)
 815         {
 816             fc = get_enum_fc(type);
 817         }
 818         else
 819         {
 820             fc = get_basic_fc(type);
 821
 822             if (fc == RPC_FC_BIND_PRIMITIVE)
 823                 fc = RPC_FC_IGNORE;
 824         }
 825
 826         print_file(file, indent, "0x%02x,    /* %s */\n",
 827                    fc, string_of_type(fc));
 828         size = 2; /* includes param type prefix */
 829     }
 830     else
 831     {
 832         if (is_return)
 833             print_file(file, indent, "0x52,    /* FC_RETURN_PARAM */\n");
 834         else if (is_in && is_out)
 835             print_file(file, indent, "0x50,    /* FC_IN_OUT_PARAM */\n");
 836         else if (is_out)
 837             print_file(file, indent, "0x51,    /* FC_OUT_PARAM */\n");
 838         else
 839             print_file(file, indent, "0x4d,    /* FC_IN_PARAM */\n");
 840
 841         print_file(file, indent, "0x01,\n");
 842         print_file(file, indent, "NdrFcShort(0x%hx),\n", type->typestring_offset);
 843         size = 4; /* includes param type prefix */
 844     }
 845     return size;
 846 }
 847
 848 static void write_procformatstring_stmts(FILE *file, int indent, const statement_list_t *stmts, type_pred_t pred)
 849 {
 850     const statement_t *stmt;
 851     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
 852     {
 853         if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE)
 854         {
 855             const statement_t *stmt_func;
 856             if (!pred(stmt->u.type))
 857                 continue;
 858             STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(stmt->u.type))
 859             {
 860                 const var_t *func = stmt_func->u.var;
 861                 if (is_local(func->attrs)) continue;
 862                 /* emit argument data */
 863                 if (type_get_function_args(func->type))
 864                 {
 865                     const var_t *var;
 866                     LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
 867                         write_procformatstring_type(file, indent, var->name, var->type, var->attrs, FALSE);
 868                 }
 869
 870                 /* emit return value data */
 871                 if (is_void(type_function_get_rettype(func->type)))
 872                 {
 873                     print_file(file, indent, "0x5b,    /* FC_END */\n");
 874                     print_file(file, indent, "0x5c,    /* FC_PAD */\n");
 875                 }
 876                 else
 877                     write_procformatstring_type(file, indent, "return value", type_function_get_rettype(func->type), NULL, TRUE);
 878             }
 879         }
 880         else if (stmt->type == STMT_LIBRARY)
 881             write_procformatstring_stmts(file, indent, stmt->u.lib->stmts, pred);
 882     }
 883 }
 884
 885 void write_procformatstring(FILE *file, const statement_list_t *stmts, type_pred_t pred)
 886 {
 887     int indent = 0;
 888
 889     print_file(file, indent, "static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
 890     print_file(file, indent, "{\n");
 891     indent++;
 892     print_file(file, indent, "0,\n");
 893     print_file(file, indent, "{\n");
 894     indent++;
 895
 896     write_procformatstring_stmts(file, indent, stmts, pred);
 897
 898     print_file(file, indent, "0x0\n");
 899     indent--;
 900     print_file(file, indent, "}\n");
 901     indent--;
 902     print_file(file, indent, "};\n");
 903     print_file(file, indent, "\n");
 904 }
 905
 906 static int write_base_type(FILE *file, const type_t *type, int convert_to_signed_type, unsigned int *typestring_offset)
 907 {
 908     unsigned char fc;
 909
 910     if (type_get_type(type) == TYPE_BASIC)
 911         fc = get_basic_fc(type);
 912     else if (type_get_type(type) == TYPE_ENUM)
 913         fc = get_enum_fc(type);
 914     else
 915         return 0;
 916
 917     if (convert_to_signed_type)
 918     {
 919         switch(fc)
 920         {
 921         case RPC_FC_USMALL:
 922             fc = RPC_FC_SMALL;
 923             break;
 924         case RPC_FC_USHORT:
 925             fc = RPC_FC_SHORT;
 926             break;
 927         case RPC_FC_ULONG:
 928             fc = RPC_FC_LONG;
 929             break;
 930         }
 931     }
 932
 933     print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc));
 934     *typestring_offset += 1;
 935     return 1;
 936 }
 937
 938 /* write conformance / variance descriptor */
 939 static unsigned int write_conf_or_var_desc(FILE *file, const type_t *structure,
 940                                            unsigned int baseoff, const type_t *type,
 941                                            const expr_t *expr)
 942 {
 943     unsigned char operator_type = 0;
 944     unsigned char conftype = RPC_FC_NORMAL_CONFORMANCE;
 945     const char *conftype_string = "";
 946     const char *operator_string = "no operators";
 947     const expr_t *subexpr;
 948
 949     if (!expr)
 950     {
 951         print_file(file, 2, "NdrFcLong(0xffffffff),\t/* -1 */\n");
 952         return 4;
 953     }
 954
 955     if (!structure)
 956     {
 957         /* Top-level conformance calculations are done inline.  */
 958         print_file (file, 2, "0x%x,\t/* Corr desc: parameter */\n",
 959                     RPC_FC_TOP_LEVEL_CONFORMANCE);
 960         print_file (file, 2, "0x0,\n");
 961         print_file (file, 2, "NdrFcShort(0x0),\n");
 962         return 4;
 963     }
 964
 965     if (expr->is_const)
 966     {
 967         if (expr->cval > UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX)
 968             error("write_conf_or_var_desc: constant value %ld is greater than "
 969                   "the maximum constant size of %d\n", expr->cval,
 970                   UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX);
 971
 972         print_file(file, 2, "0x%x, /* Corr desc: constant, val = %ld */\n",
 973                    RPC_FC_CONSTANT_CONFORMANCE, expr->cval);
 974         print_file(file, 2, "0x%lx,\n", expr->cval >> 16);
 975         print_file(file, 2, "NdrFcShort(0x%hx),\n", (unsigned short)expr->cval);
 976
 977         return 4;
 978     }
 979
 980     if (is_ptr(type) || (is_array(type) && type_array_is_decl_as_ptr(type)))
 981     {
 982         conftype = RPC_FC_POINTER_CONFORMANCE;
 983         conftype_string = "field pointer, ";
 984     }
 985
 986     subexpr = expr;
 987     switch (subexpr->type)
 988     {
 989     case EXPR_PPTR:
 990         subexpr = subexpr->ref;
 991         operator_type = RPC_FC_DEREFERENCE;
 992         operator_string = "FC_DEREFERENCE";
 993         break;
 994     case EXPR_DIV:
 995         if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
 996         {
 997             subexpr = subexpr->ref;
 998             operator_type = RPC_FC_DIV_2;
 999             operator_string = "FC_DIV_2";
1000         }
1001         break;
1002     case EXPR_MUL:
1003         if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2))
1004         {
1005             subexpr = subexpr->ref;
1006             operator_type = RPC_FC_MULT_2;
1007             operator_string = "FC_MULT_2";
1008         }
1009         break;
1010     case EXPR_SUB:
1011         if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
1012         {
1013             subexpr = subexpr->ref;
1014             operator_type = RPC_FC_SUB_1;
1015             operator_string = "FC_SUB_1";
1016         }
1017         break;
1018     case EXPR_ADD:
1019         if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1))
1020         {
1021             subexpr = subexpr->ref;
1022             operator_type = RPC_FC_ADD_1;
1023             operator_string = "FC_ADD_1";
1024         }
1025         break;
1026     default:
1027         break;
1028     }
1029
1030     if (subexpr->type == EXPR_IDENTIFIER)
1031     {
1032         const type_t *correlation_variable = NULL;
1033         unsigned char param_type = 0;
1034         unsigned int offset = 0;
1035         const var_t *var;
1036         var_list_t *fields = type_struct_get_fields(structure);
1037
1038         if (fields) LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry )
1039         {
1040             unsigned int size = field_memsize( var->type, &offset );
1041             if (var->name && !strcmp(var->name, subexpr->u.sval))
1042             {
1043                 correlation_variable = var->type;
1044                 break;
1045             }
1046             offset += size;
1047         }
1048         if (!correlation_variable)
1049             error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
1050                   subexpr->u.sval);
1051
1052         correlation_variable = expr_resolve_type(NULL, structure, expr);
1053
1054         offset -= baseoff;
1055
1056         if (type_get_type(correlation_variable) == TYPE_BASIC)
1057         {
1058             switch (get_basic_fc(correlation_variable))
1059             {
1060             case RPC_FC_CHAR:
1061             case RPC_FC_SMALL:
1062                 param_type = RPC_FC_SMALL;
1063                 break;
1064             case RPC_FC_BYTE:
1065             case RPC_FC_USMALL:
1066                 param_type = RPC_FC_USMALL;
1067                 break;
1068             case RPC_FC_WCHAR:
1069             case RPC_FC_SHORT:
1070                 param_type = RPC_FC_SHORT;
1071                 break;
1072             case RPC_FC_USHORT:
1073                 param_type = RPC_FC_USHORT;
1074                 break;
1075             case RPC_FC_LONG:
1076                 param_type = RPC_FC_LONG;
1077                 break;
1078             case RPC_FC_ULONG:
1079                 param_type = RPC_FC_ULONG;
1080                 break;
1081             default:
1082                 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n",
1083                       get_basic_fc(correlation_variable));
1084             }
1085         }
1086         else if (type_get_type(correlation_variable) == TYPE_ENUM)
1087         {
1088             if (get_enum_fc(correlation_variable) == RPC_FC_ENUM32)
1089                 param_type = RPC_FC_LONG;
1090             else
1091                 param_type = RPC_FC_SHORT;
1092         }
1093         else if (type_get_type(correlation_variable) == TYPE_POINTER)
1094         {
1095             if (pointer_size == 8)
1096                 param_type = RPC_FC_HYPER;
1097             else
1098                 param_type = RPC_FC_LONG;
1099         }
1100         else
1101         {
1102             error("write_conf_or_var_desc: non-arithmetic type used as correlation variable %s\n",
1103                   subexpr->u.sval);
1104             return 0;
1105         }
1106
1107         print_file(file, 2, "0x%x, /* Corr desc: %s%s */\n",
1108                    conftype | param_type, conftype_string, string_of_type(param_type));
1109         print_file(file, 2, "0x%x, /* %s */\n", operator_type, operator_string);
1110         print_file(file, 2, "NdrFcShort(0x%hx),\t/* offset = %d */\n",
1111                    offset, offset);
1112     }
1113     else
1114     {
1115         unsigned int callback_offset = 0;
1116         struct expr_eval_routine *eval;
1117         int found = 0;
1118
1119         LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
1120         {
1121             if (eval->structure == structure ||
1122                 (eval->structure->name && structure->name &&
1123                  !strcmp(eval->structure->name, structure->name) &&
1124                  !compare_expr(eval->expr, expr)))
1125             {
1126                 found = 1;
1127                 break;
1128             }
1129             callback_offset++;
1130         }
1131
1132         if (!found)
1133         {
1134             eval = xmalloc (sizeof(*eval));
1135             eval->structure = structure;
1136             eval->baseoff = baseoff;
1137             eval->expr = expr;
1138             list_add_tail (&expr_eval_routines, &eval->entry);
1139         }
1140
1141         if (callback_offset > USHRT_MAX)
1142             error("Maximum number of callback routines reached\n");
1143
1144         print_file(file, 2, "0x%x, /* Corr desc: %s */\n", conftype, conftype_string);
1145         print_file(file, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK");
1146         print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", callback_offset, callback_offset);
1147     }
1148     return 4;
1149 }
1150
1151 /* return size and start offset of a data field based on current offset */
1152 static unsigned int field_memsize(const type_t *type, unsigned int *offset)
1153 {
1154     unsigned int align = 0;
1155     unsigned int size = type_memsize( type, &align );
1156
1157     *offset = ROUND_SIZE( *offset, align );
1158     return size;
1159 }
1160
1161 static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align)
1162 {
1163     unsigned int size = 0;
1164     unsigned int max_align;
1165     const var_t *v;
1166
1167     if (!fields) return 0;
1168     LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
1169     {
1170         unsigned int falign = 0;
1171         unsigned int fsize = type_memsize(v->type, &falign);
1172         if (*align < falign) *align = falign;
1173         falign = clamp_align(falign);
1174         size = ROUND_SIZE(size, falign);
1175         size += fsize;
1176     }
1177
1178     max_align = clamp_align(*align);
1179     size = ROUND_SIZE(size, max_align);
1180
1181     return size;
1182 }
1183
1184 static unsigned int union_memsize(const var_list_t *fields, unsigned int *pmaxa)
1185 {
1186     unsigned int size, maxs = 0;
1187     unsigned int align = *pmaxa;
1188     const var_t *v;
1189
1190     if (fields) LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry )
1191     {
1192         /* we could have an empty default field with NULL type */
1193         if (v->type)
1194         {
1195             size = type_memsize(v->type, &align);
1196             if (maxs < size) maxs = size;
1197             if (*pmaxa < align) *pmaxa = align;
1198         }
1199     }
1200
1201     return maxs;
1202 }
1203
1204 unsigned int type_memsize(const type_t *t, unsigned int *align)
1205 {
1206     unsigned int size = 0;
1207
1208     switch (type_get_type(t))
1209     {
1210     case TYPE_BASIC:
1211         switch (get_basic_fc(t))
1212         {
1213         case RPC_FC_BYTE:
1214         case RPC_FC_CHAR:
1215         case RPC_FC_USMALL:
1216         case RPC_FC_SMALL:
1217             size = 1;
1218             if (size > *align) *align = size;
1219             break;
1220         case RPC_FC_WCHAR:
1221         case RPC_FC_USHORT:
1222         case RPC_FC_SHORT:
1223             size = 2;
1224             if (size > *align) *align = size;
1225             break;
1226         case RPC_FC_ULONG:
1227         case RPC_FC_LONG:
1228         case RPC_FC_ERROR_STATUS_T:
1229         case RPC_FC_FLOAT:
1230             size = 4;
1231             if (size > *align) *align = size;
1232             break;
1233         case RPC_FC_HYPER:
1234         case RPC_FC_DOUBLE:
1235             size = 8;
1236             if (size > *align) *align = size;
1237             break;
1238         case RPC_FC_INT3264:
1239         case RPC_FC_UINT3264:
1240             assert( pointer_size );
1241             size = pointer_size;
1242             if (size > *align) *align = size;
1243             break;
1244         default:
1245             error("type_memsize: Unknown type 0x%x\n", get_basic_fc(t));
1246             size = 0;
1247         }
1248         break;
1249     case TYPE_ENUM:
1250         switch (get_enum_fc(t))
1251         {
1252         case RPC_FC_ENUM16:
1253         case RPC_FC_ENUM32:
1254             size = 4;
1255             if (size > *align) *align = size;
1256             break;
1257         default:
1258             error("type_memsize: Unknown enum type\n");
1259             size = 0;
1260         }
1261         break;
1262     case TYPE_STRUCT:
1263         size = fields_memsize(type_struct_get_fields(t), align);
1264         break;
1265     case TYPE_ENCAPSULATED_UNION:
1266         size = fields_memsize(type_encapsulated_union_get_fields(t), align);
1267         break;
1268     case TYPE_UNION:
1269         size = union_memsize(type_union_get_cases(t), align);
1270         break;
1271     case TYPE_POINTER:
1272         assert( pointer_size );
1273         size = pointer_size;
1274         if (size > *align) *align = size;
1275         break;
1276     case TYPE_ARRAY:
1277         if (!type_array_is_decl_as_ptr(t))
1278         {
1279             if (is_conformant_array(t))
1280             {
1281                 type_memsize(type_array_get_element(t), align);
1282                 size = 0;
1283             }
1284             else
1285                 size = type_array_get_dim(t) *
1286                     type_memsize(type_array_get_element(t), align);
1287         }
1288         else /* declared as a pointer */
1289         {
1290             assert( pointer_size );
1291             size = pointer_size;
1292             if (size > *align) *align = size;
1293         }
1294         break;
1295     case TYPE_INTERFACE:
1296     case TYPE_ALIAS:
1297     case TYPE_VOID:
1298     case TYPE_COCLASS:
1299     case TYPE_MODULE:
1300     case TYPE_FUNCTION:
1301     case TYPE_BITFIELD:
1302         /* these types should not be encountered here due to language
1303          * restrictions (interface, void, coclass, module), logical
1304          * restrictions (alias - due to type_get_type call above) or
1305          * checking restrictions (function, bitfield). */
1306         assert(0);
1307     }
1308
1309     return size;
1310 }
1311
1312 int is_full_pointer_function(const var_t *func)
1313 {
1314     const var_t *var;
1315     if (type_has_full_pointer(type_function_get_rettype(func->type), func->attrs, TRUE))
1316         return TRUE;
1317     if (!type_get_function_args(func->type))
1318         return FALSE;
1319     LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
1320         if (type_has_full_pointer( var->type, var->attrs, TRUE ))
1321             return TRUE;
1322     return FALSE;
1323 }
1324
1325 void write_full_pointer_init(FILE *file, int indent, const var_t *func, int is_server)
1326 {
1327     print_file(file, indent, "__frame->_StubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,%s);\n",
1328                    is_server ? "XLAT_SERVER" : "XLAT_CLIENT");
1329     fprintf(file, "\n");
1330 }
1331
1332 void write_full_pointer_free(FILE *file, int indent, const var_t *func)
1333 {
1334     print_file(file, indent, "NdrFullPointerXlatFree(__frame->_StubMsg.FullPtrXlatTables);\n");
1335     fprintf(file, "\n");
1336 }
1337
1338 static unsigned int write_nonsimple_pointer(FILE *file, const attr_list_t *attrs,
1339                                             const type_t *type,
1340                                             int toplevel_param,
1341                                             unsigned int offset,
1342                                             unsigned int *typeformat_offset)
1343 {
1344     unsigned int start_offset = *typeformat_offset;
1345     short reloff = offset - (*typeformat_offset + 2);
1346     int in_attr, out_attr;
1347     int pointer_type;
1348     unsigned char flags = 0;
1349
1350     pointer_type = get_pointer_fc(type, attrs, toplevel_param);
1351
1352     in_attr = is_attr(attrs, ATTR_IN);
1353     out_attr = is_attr(attrs, ATTR_OUT);
1354     if (!in_attr && !out_attr) in_attr = 1;
1355
1356     if (out_attr && !in_attr && pointer_type == RPC_FC_RP)
1357         flags |= RPC_FC_P_ONSTACK;
1358
1359     if (is_ptr(type) && is_declptr(type_pointer_get_ref(type)))
1360         flags |= RPC_FC_P_DEREF;
1361
1362     print_file(file, 2, "0x%x, 0x%x,\t\t/* %s",
1363                pointer_type,
1364                flags,
1365                string_of_type(pointer_type));
1366     if (file)
1367     {
1368         if (flags & RPC_FC_P_ONSTACK)
1369             fprintf(file, " [allocated_on_stack]");
1370         if (flags & RPC_FC_P_DEREF)
1371             fprintf(file, " [pointer_deref]");
1372         fprintf(file, " */\n");
1373     }
1374
1375     print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", reloff, reloff, offset);
1376     *typeformat_offset += 4;
1377
1378     return start_offset;
1379 }
1380
1381 static unsigned int write_simple_pointer(FILE *file, const attr_list_t *attrs, const type_t *type, int toplevel_param)
1382 {
1383     unsigned char fc;
1384     unsigned char pointer_fc;
1385     const type_t *ref;
1386     int in_attr = is_attr(attrs, ATTR_IN);
1387     int out_attr = is_attr(attrs, ATTR_OUT);
1388     unsigned char flags = RPC_FC_P_SIMPLEPOINTER;
1389
1390     /* for historical reasons, write_simple_pointer also handled string types,
1391      * but no longer does. catch bad uses of the function with this check */
1392     if (is_string_type(attrs, type))
1393         error("write_simple_pointer: can't handle type %s which is a string type\n", type->name);
1394
1395     pointer_fc = get_pointer_fc(type, attrs, toplevel_param);
1396
1397     ref = type_pointer_get_ref(type);
1398     if (type_get_type(ref) == TYPE_ENUM)
1399         fc = get_enum_fc(ref);
1400     else
1401         fc = get_basic_fc(ref);
1402
1403     if (out_attr && !in_attr)
1404         flags |= RPC_FC_P_ONSTACK;
1405
1406     print_file(file, 2, "0x%02x, 0x%x,\t/* %s %s[simple_pointer] */\n",
1407                pointer_fc, flags, string_of_type(pointer_fc),
1408                flags & RPC_FC_P_ONSTACK ? "[allocated_on_stack] " : "");
1409     print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc));
1410     print_file(file, 2, "0x5c,\t/* FC_PAD */\n");
1411     return 4;
1412 }
1413
1414 static void print_start_tfs_comment(FILE *file, type_t *t, unsigned int tfsoff)
1415 {
1416     print_file(file, 0, "/* %u (", tfsoff);
1417     write_type_decl(file, t, NULL);
1418     print_file(file, 0, ") */\n");
1419 }
1420
1421 static unsigned int write_pointer_tfs(FILE *file, const attr_list_t *attrs,
1422                                       type_t *type, unsigned int ref_offset,
1423                                       int toplevel_param,
1424                                       unsigned int *typestring_offset)
1425 {
1426     unsigned int offset = *typestring_offset;
1427     type_t *ref = type_pointer_get_ref(type);
1428
1429     print_start_tfs_comment(file, type, offset);
1430     update_tfsoff(type, offset, file);
1431
1432     switch (typegen_detect_type(ref, attrs, TDT_ALL_TYPES))
1433     {
1434     case TGT_BASIC:
1435     case TGT_ENUM:
1436         *typestring_offset += write_simple_pointer(file, attrs, type,
1437                                                    toplevel_param);
1438         break;
1439     default:
1440         if (ref_offset)
1441             write_nonsimple_pointer(file, attrs, type,
1442                                     toplevel_param,
1443                                     ref_offset,
1444                                     typestring_offset);
1445         break;
1446     }
1447
1448     return offset;
1449 }
1450
1451 static int processed(const type_t *type)
1452 {
1453     return type->typestring_offset && !type->tfswrite;
1454 }
1455
1456 static int user_type_has_variable_size(const type_t *t)
1457 {
1458     if (is_ptr(t))
1459         return TRUE;
1460     else if (type_get_type(t) == TYPE_STRUCT)
1461     {
1462         switch (get_struct_fc(t))
1463         {
1464         case RPC_FC_PSTRUCT:
1465         case RPC_FC_CSTRUCT:
1466         case RPC_FC_CPSTRUCT:
1467         case RPC_FC_CVSTRUCT:
1468             return TRUE;
1469         }
1470     }
1471     /* Note: Since this only applies to user types, we can't have a conformant
1472        array here, and strings should get filed under pointer in this case.  */
1473     return FALSE;
1474 }
1475
1476 static void write_user_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
1477 {
1478     unsigned int start, absoff, flags;
1479     unsigned int align = 0, ualign = 0;
1480     const char *name = NULL;
1481     type_t *utype = get_user_type(type, &name);
1482     unsigned int usize = type_memsize(utype, &ualign);
1483     unsigned int size = type_memsize(type, &align);
1484     unsigned short funoff = user_type_offset(name);
1485     short reloff;
1486
1487     guard_rec(type);
1488
1489     if(user_type_has_variable_size(utype)) usize = 0;
1490
1491     if (type_get_type(utype) == TYPE_BASIC ||
1492         type_get_type(utype) == TYPE_ENUM)
1493     {
1494         unsigned char fc;
1495
1496         if (type_get_type(utype) == TYPE_ENUM)
1497             fc = get_enum_fc(utype);
1498         else
1499             fc = get_basic_fc(utype);
1500
1501         absoff = *tfsoff;
1502         print_start_tfs_comment(file, utype, absoff);
1503         print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
1504         print_file(file, 2, "0x5c,\t/* FC_PAD */\n");
1505         *tfsoff += 2;
1506     }
1507     else
1508     {
1509         if (!processed(utype))
1510             write_embedded_types(file, NULL, utype, utype->name, TRUE, tfsoff);
1511         absoff = utype->typestring_offset;
1512     }
1513
1514     if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == RPC_FC_RP)
1515         flags = 0x40;
1516     else if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == RPC_FC_UP)
1517         flags = 0x80;
1518     else
1519         flags = 0;
1520
1521     start = *tfsoff;
1522     update_tfsoff(type, start, file);
1523     print_start_tfs_comment(file, type, start);
1524     print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", RPC_FC_USER_MARSHAL);
1525     print_file(file, 2, "0x%x,\t/* Alignment= %d, Flags= %02x */\n",
1526                flags | (ualign - 1), ualign - 1, flags);
1527     print_file(file, 2, "NdrFcShort(0x%hx),\t/* Function offset= %hu */\n", funoff, funoff);
1528     print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", size, size);
1529     print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", usize, usize);
1530     *tfsoff += 8;
1531     reloff = absoff - *tfsoff;
1532     print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", reloff, reloff, absoff);
1533     *tfsoff += 2;
1534 }
1535
1536 static void write_member_type(FILE *file, const type_t *cont,
1537                               int cont_is_complex, const attr_list_t *attrs,
1538                               const type_t *type, unsigned int *corroff,
1539                               unsigned int *tfsoff)
1540 {
1541     if (is_embedded_complex(type) && !is_conformant_array(type))
1542     {
1543         unsigned int absoff;
1544         short reloff;
1545
1546         if (type_get_type(type) == TYPE_UNION && is_attr(attrs, ATTR_SWITCHIS))
1547         {
1548             absoff = *corroff;
1549             *corroff += 8;
1550         }
1551         else
1552         {
1553             absoff = type->typestring_offset;
1554         }
1555         reloff = absoff - (*tfsoff + 2);
1556
1557         print_file(file, 2, "0x4c,\t/* FC_EMBEDDED_COMPLEX */\n");
1558         /* padding is represented using FC_STRUCTPAD* types, so presumably
1559          * this is left over in the format for historical purposes in MIDL
1560          * or rpcrt4. */
1561         print_file(file, 2, "0x0,\n");
1562         print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n",
1563                    reloff, reloff, absoff);
1564         *tfsoff += 4;
1565     }
1566     else if (is_ptr(type) || is_conformant_array(type))
1567     {
1568         unsigned char fc = cont_is_complex ? RPC_FC_POINTER : RPC_FC_LONG;
1569         print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
1570         *tfsoff += 1;
1571     }
1572     else if (!write_base_type(file, type, TRUE, tfsoff))
1573         error("Unsupported member type %d\n", type_get_type(type));
1574 }
1575
1576 static void write_array_element_type(FILE *file, const type_t *type,
1577                                      int cont_is_complex, unsigned int *tfsoff)
1578 {
1579     type_t *elem = type_array_get_element(type);
1580
1581     if (!is_embedded_complex(elem) && is_ptr(elem))
1582     {
1583         type_t *ref = type_pointer_get_ref(elem);
1584
1585         if (processed(ref))
1586         {
1587             write_nonsimple_pointer(file, NULL, elem, FALSE, ref->typestring_offset, tfsoff);
1588             return;
1589         }
1590         if (!is_string_type(NULL, elem) &&
1591             (type_get_type(ref) == TYPE_BASIC || type_get_type(ref) == TYPE_ENUM))
1592         {
1593             *tfsoff += write_simple_pointer(file, NULL, elem, FALSE);
1594             return;
1595         }
1596     }
1597     return write_member_type(file, type, cont_is_complex, NULL, elem, NULL, tfsoff);
1598 }
1599
1600 static void write_end(FILE *file, unsigned int *tfsoff)
1601 {
1602     if (*tfsoff % 2 == 0)
1603     {
1604         print_file(file, 2, "0x%x,\t\t/* FC_PAD */\n", RPC_FC_PAD);
1605         *tfsoff += 1;
1606     }
1607     print_file(file, 2, "0x%x,\t\t/* FC_END */\n", RPC_FC_END);
1608     *tfsoff += 1;
1609 }
1610
1611 static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
1612 {
1613     unsigned int offset = 0;
1614     var_list_t *fs = type_struct_get_fields(type);
1615     var_t *f;
1616
1617     if (fs) LIST_FOR_EACH_ENTRY(f, fs, var_t, entry)
1618     {
1619         type_t *ft = f->type;
1620         unsigned int size = field_memsize( ft, &offset );
1621         if (type_get_type(ft) == TYPE_UNION && is_attr(f->attrs, ATTR_SWITCHIS))
1622         {
1623             short reloff;
1624             unsigned int absoff = ft->typestring_offset;
1625             if (is_attr(ft->attrs, ATTR_SWITCHTYPE))
1626                 absoff += 8; /* we already have a corr descr, skip it */
1627             reloff = absoff - (*tfsoff + 6);
1628             print_file(file, 0, "/* %d */\n", *tfsoff);
1629             print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION);
1630             print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", RPC_FC_LONG);
1631             write_conf_or_var_desc(file, current_structure, offset, ft,
1632                                    get_attrp(f->attrs, ATTR_SWITCHIS));
1633             print_file(file, 2, "NdrFcShort(%hd),\t/* Offset= %hd (%u) */\n",
1634                        reloff, reloff, absoff);
1635             *tfsoff += 8;
1636         }
1637         offset += size;
1638     }
1639 }
1640
1641 static int write_pointer_description_offsets(
1642     FILE *file, const attr_list_t *attrs, type_t *type,
1643     unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
1644     unsigned int *typestring_offset)
1645 {
1646     int written = 0;
1647     unsigned int align;
1648
1649     if ((is_ptr(type) && type_get_type(type_pointer_get_ref(type)) != TYPE_INTERFACE) ||
1650         (is_array(type) && type_array_is_decl_as_ptr(type)))
1651     {
1652         if (offset_in_memory && offset_in_buffer)
1653         {
1654             unsigned int memsize;
1655
1656             /* pointer instance
1657              *
1658              * note that MSDN states that for pointer layouts in structures,
1659              * this is a negative offset from the end of the structure, but
1660              * this statement is incorrect. all offsets are positive */
1661             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Memory offset = %d */\n", *offset_in_memory, *offset_in_memory);
1662             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Buffer offset = %d */\n", *offset_in_buffer, *offset_in_buffer);
1663
1664             align = 0;
1665             memsize = type_memsize(type, &align);
1666             *offset_in_memory += memsize;
1667             /* increment these separately as in the case of conformant (varying)
1668              * structures these start at different values */
1669             *offset_in_buffer += memsize;
1670         }
1671         *typestring_offset += 4;
1672
1673         if (is_ptr(type))
1674         {
1675             type_t *ref = type_pointer_get_ref(type);
1676
1677             if (is_string_type(attrs, type))
1678                 write_string_tfs(file, attrs, type, FALSE, NULL, typestring_offset);
1679             else if (processed(ref))
1680                 write_nonsimple_pointer(file, attrs, type, FALSE, ref->typestring_offset, typestring_offset);
1681             else if (type_get_type(ref) == TYPE_BASIC || type_get_type(ref) == TYPE_ENUM)
1682                 *typestring_offset += write_simple_pointer(file, attrs, type, FALSE);
1683             else
1684                 error("write_pointer_description_offsets: type format string unknown\n");
1685         }
1686         else
1687         {
1688             unsigned int offset = type->typestring_offset;
1689             /* skip over the pointer that is written for strings, since a
1690              * pointer has to be written in-place here */
1691             if (is_string_type(attrs, type))
1692                 offset += 4;
1693             write_nonsimple_pointer(file, attrs, type, FALSE, offset, typestring_offset);
1694         }
1695
1696         return 1;
1697     }
1698
1699     if (is_array(type))
1700     {
1701         return write_pointer_description_offsets(
1702             file, attrs, type_array_get_element(type), offset_in_memory,
1703             offset_in_buffer, typestring_offset);
1704     }
1705     else if (is_non_complex_struct(type))
1706     {
1707         /* otherwise search for interesting fields to parse */
1708         const var_t *v;
1709         LIST_FOR_EACH_ENTRY( v, type_struct_get_fields(type), const var_t, entry )
1710         {
1711             if (offset_in_memory && offset_in_buffer)
1712             {
1713                 unsigned int padding;
1714                 align = 0;
1715                 type_memsize(v->type, &align);
1716                 padding = ROUNDING(*offset_in_memory, align);
1717                 *offset_in_memory += padding;
1718                 *offset_in_buffer += padding;
1719             }
1720             written += write_pointer_description_offsets(
1721                 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1722                 typestring_offset);
1723         }
1724     }
1725     else
1726     {
1727         if (offset_in_memory && offset_in_buffer)
1728         {
1729             unsigned int memsize;
1730             align = 0;
1731             memsize = type_memsize(type, &align);
1732             *offset_in_memory += memsize;
1733             /* increment these separately as in the case of conformant (varying)
1734              * structures these start at different values */
1735             *offset_in_buffer += memsize;
1736         }
1737     }
1738
1739     return written;
1740 }
1741
1742 static int write_no_repeat_pointer_descriptions(
1743     FILE *file, const attr_list_t *attrs, type_t *type,
1744     unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
1745     unsigned int *typestring_offset)
1746 {
1747     int written = 0;
1748     unsigned int align;
1749
1750     if (is_ptr(type) ||
1751         (is_conformant_array(type) && type_array_is_decl_as_ptr(type)))
1752     {
1753         print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", RPC_FC_NO_REPEAT);
1754         print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD);
1755         *typestring_offset += 2;
1756
1757         return write_pointer_description_offsets(file, attrs, type,
1758                        offset_in_memory, offset_in_buffer, typestring_offset);
1759     }
1760
1761     if (is_non_complex_struct(type))
1762     {
1763         const var_t *v;
1764         LIST_FOR_EACH_ENTRY( v, type_struct_get_fields(type), const var_t, entry )
1765         {
1766             if (offset_in_memory && offset_in_buffer)
1767             {
1768                 unsigned int padding;
1769                 align = 0;
1770                 type_memsize(v->type, &align);
1771                 padding = ROUNDING(*offset_in_memory, align);
1772                 *offset_in_memory += padding;
1773                 *offset_in_buffer += padding;
1774             }
1775             written += write_no_repeat_pointer_descriptions(
1776                 file, v->attrs, v->type,
1777                 offset_in_memory, offset_in_buffer, typestring_offset);
1778         }
1779     }
1780     else
1781     {
1782         unsigned int memsize;
1783         align = 0;
1784         memsize = type_memsize(type, &align);
1785         *offset_in_memory += memsize;
1786         /* increment these separately as in the case of conformant (varying)
1787          * structures these start at different values */
1788         *offset_in_buffer += memsize;
1789     }
1790
1791     return written;
1792 }
1793
1794 /* Note: if file is NULL return value is number of pointers to write, else
1795  * it is the number of type format characters written */
1796 static int write_fixed_array_pointer_descriptions(
1797     FILE *file, const attr_list_t *attrs, type_t *type,
1798     unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
1799     unsigned int *typestring_offset)
1800 {
1801     unsigned int align;
1802     int pointer_count = 0;
1803
1804     if (type_get_type(type) == TYPE_ARRAY &&
1805         !type_array_has_conformance(type) && !type_array_has_variance(type))
1806     {
1807         unsigned int temp = 0;
1808         /* unfortunately, this needs to be done in two passes to avoid
1809          * writing out redundant FC_FIXED_REPEAT descriptions */
1810         pointer_count = write_pointer_description_offsets(
1811             NULL, attrs, type_array_get_element(type), NULL, NULL, &temp);
1812         if (pointer_count > 0)
1813         {
1814             unsigned int increment_size;
1815             unsigned int offset_of_array_pointer_mem = 0;
1816             unsigned int offset_of_array_pointer_buf = 0;
1817
1818             align = 0;
1819             increment_size = type_memsize(type_array_get_element(type), &align);
1820
1821             print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", RPC_FC_FIXED_REPEAT);
1822             print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD);
1823             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Iterations = %d */\n", type_array_get_dim(type), type_array_get_dim(type));
1824             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", increment_size, increment_size);
1825             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
1826             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", pointer_count, pointer_count);
1827             *typestring_offset += 10;
1828
1829             pointer_count = write_pointer_description_offsets(
1830                 file, attrs, type, &offset_of_array_pointer_mem,
1831                 &offset_of_array_pointer_buf, typestring_offset);
1832         }
1833     }
1834     else if (type_get_type(type) == TYPE_STRUCT)
1835     {
1836         const var_t *v;
1837         LIST_FOR_EACH_ENTRY( v, type_struct_get_fields(type), const var_t, entry )
1838         {
1839             if (offset_in_memory && offset_in_buffer)
1840             {
1841                 unsigned int padding;
1842                 align = 0;
1843                 type_memsize(v->type, &align);
1844                 padding = ROUNDING(*offset_in_memory, align);
1845                 *offset_in_memory += padding;
1846                 *offset_in_buffer += padding;
1847             }
1848             pointer_count += write_fixed_array_pointer_descriptions(
1849                 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1850                 typestring_offset);
1851         }
1852     }
1853     else
1854     {
1855         if (offset_in_memory && offset_in_buffer)
1856         {
1857             unsigned int memsize;
1858             align = 0;
1859             memsize = type_memsize(type, &align);
1860             *offset_in_memory += memsize;
1861             /* increment these separately as in the case of conformant (varying)
1862              * structures these start at different values */
1863             *offset_in_buffer += memsize;
1864         }
1865     }
1866
1867     return pointer_count;
1868 }
1869
1870 /* Note: if file is NULL return value is number of pointers to write, else
1871  * it is the number of type format characters written */
1872 static int write_conformant_array_pointer_descriptions(
1873     FILE *file, const attr_list_t *attrs, type_t *type,
1874     unsigned int offset_in_memory, unsigned int *typestring_offset)
1875 {
1876     unsigned int align;
1877     int pointer_count = 0;
1878
1879     if (is_conformant_array(type) && !type_array_has_variance(type))
1880     {
1881         unsigned int temp = 0;
1882         /* unfortunately, this needs to be done in two passes to avoid
1883          * writing out redundant FC_VARIABLE_REPEAT descriptions */
1884         pointer_count = write_pointer_description_offsets(
1885             NULL, attrs, type_array_get_element(type), NULL, NULL, &temp);
1886         if (pointer_count > 0)
1887         {
1888             unsigned int increment_size;
1889             unsigned int offset_of_array_pointer_mem = offset_in_memory;
1890             unsigned int offset_of_array_pointer_buf = offset_in_memory;
1891
1892             align = 0;
1893             increment_size = type_memsize(type_array_get_element(type), &align);
1894
1895             if (increment_size > USHRT_MAX)
1896                 error("array size of %u bytes is too large\n", increment_size);
1897
1898             print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT);
1899             print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", RPC_FC_FIXED_OFFSET);
1900             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", increment_size, increment_size);
1901             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", offset_in_memory, offset_in_memory);
1902             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", pointer_count, pointer_count);
1903             *typestring_offset += 8;
1904
1905             pointer_count = write_pointer_description_offsets(
1906                 file, attrs, type_array_get_element(type),
1907                 &offset_of_array_pointer_mem, &offset_of_array_pointer_buf,
1908                 typestring_offset);
1909         }
1910     }
1911
1912     return pointer_count;
1913 }
1914
1915 /* Note: if file is NULL return value is number of pointers to write, else
1916  * it is the number of type format characters written */
1917 static int write_varying_array_pointer_descriptions(
1918     FILE *file, const attr_list_t *attrs, type_t *type,
1919     unsigned int *offset_in_memory, unsigned int *offset_in_buffer,
1920     unsigned int *typestring_offset)
1921 {
1922     unsigned int align;
1923     int pointer_count = 0;
1924
1925     if (is_array(type) && type_array_has_variance(type))
1926     {
1927         unsigned int temp = 0;
1928         /* unfortunately, this needs to be done in two passes to avoid
1929          * writing out redundant FC_VARIABLE_REPEAT descriptions */
1930         pointer_count = write_pointer_description_offsets(
1931             NULL, attrs, type_array_get_element(type), NULL, NULL, &temp);
1932         if (pointer_count > 0)
1933         {
1934             unsigned int increment_size;
1935
1936             align = 0;
1937             increment_size = type_memsize(type_array_get_element(type), &align);
1938
1939             if (increment_size > USHRT_MAX)
1940                 error("array size of %u bytes is too large\n", increment_size);
1941
1942             print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT);
1943             print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", RPC_FC_VARIABLE_OFFSET);
1944             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", increment_size, increment_size);
1945             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
1946             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", pointer_count, pointer_count);
1947             *typestring_offset += 8;
1948
1949             pointer_count = write_pointer_description_offsets(
1950                 file, attrs, type_array_get_element(type), offset_in_memory,
1951                 offset_in_buffer, typestring_offset);
1952         }
1953     }
1954     else if (type_get_type(type) == TYPE_STRUCT)
1955     {
1956         const var_t *v;
1957         LIST_FOR_EACH_ENTRY( v, type_struct_get_fields(type), const var_t, entry )
1958         {
1959             if (offset_in_memory && offset_in_buffer)
1960             {
1961                 unsigned int padding;
1962
1963                 if (is_array(v->type) && type_array_has_variance(v->type))
1964                 {
1965                     *offset_in_buffer = ROUND_SIZE(*offset_in_buffer, 4);
1966                     /* skip over variance and offset in buffer */
1967                     *offset_in_buffer += 8;
1968                 }
1969
1970                 align = 0;
1971                 type_memsize(v->type, &align);
1972                 padding = ROUNDING(*offset_in_memory, align);
1973                 *offset_in_memory += padding;
1974                 *offset_in_buffer += padding;
1975             }
1976             pointer_count += write_varying_array_pointer_descriptions(
1977                 file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
1978                 typestring_offset);
1979         }
1980     }
1981     else
1982     {
1983         if (offset_in_memory && offset_in_buffer)
1984         {
1985             unsigned int memsize;
1986             align = 0;
1987             memsize = type_memsize(type, &align);
1988             *offset_in_memory += memsize;
1989             /* increment these separately as in the case of conformant (varying)
1990              * structures these start at different values */
1991             *offset_in_buffer += memsize;
1992         }
1993     }
1994
1995     return pointer_count;
1996 }
1997
1998 static void write_pointer_description(FILE *file, type_t *type,
1999                                       unsigned int *typestring_offset)
2000 {
2001     unsigned int offset_in_buffer;
2002     unsigned int offset_in_memory;
2003
2004     /* pass 1: search for single instance of a pointer (i.e. don't descend
2005      * into arrays) */
2006     if (!is_array(type))
2007     {
2008         offset_in_memory = 0;
2009         offset_in_buffer = 0;
2010         write_no_repeat_pointer_descriptions(
2011             file, NULL, type,
2012             &offset_in_memory, &offset_in_buffer, typestring_offset);
2013     }
2014
2015     /* pass 2: search for pointers in fixed arrays */
2016     offset_in_memory = 0;
2017     offset_in_buffer = 0;
2018     write_fixed_array_pointer_descriptions(
2019         file, NULL, type,
2020         &offset_in_memory, &offset_in_buffer, typestring_offset);
2021
2022     /* pass 3: search for pointers in conformant only arrays (but don't descend
2023      * into conformant varying or varying arrays) */
2024     if (is_conformant_array(type) &&
2025         (type_array_is_decl_as_ptr(type) || !current_structure))
2026         write_conformant_array_pointer_descriptions(
2027             file, NULL, type, 0, typestring_offset);
2028     else if (type_get_type(type) == TYPE_STRUCT &&
2029              get_struct_fc(type) == RPC_FC_CPSTRUCT)
2030     {
2031         unsigned int align = 0;
2032         type_t *carray = find_array_or_string_in_struct(type)->type;
2033         write_conformant_array_pointer_descriptions(
2034             file, NULL, carray,
2035             type_memsize(type, &align),
2036             typestring_offset);
2037     }
2038
2039     /* pass 4: search for pointers in varying arrays */
2040     offset_in_memory = 0;
2041     offset_in_buffer = 0;
2042     write_varying_array_pointer_descriptions(
2043             file, NULL, type,
2044             &offset_in_memory, &offset_in_buffer, typestring_offset);
2045 }
2046
2047 int is_declptr(const type_t *t)
2048 {
2049   return is_ptr(t) || (type_get_type(t) == TYPE_ARRAY && type_array_is_decl_as_ptr(t));
2050 }
2051
2052 static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
2053                                      type_t *type, int toplevel_param,
2054                                      const char *name, unsigned int *typestring_offset)
2055 {
2056     unsigned int start_offset;
2057     unsigned char rtype;
2058     type_t *elem_type;
2059
2060     start_offset = *typestring_offset;
2061     update_tfsoff(type, start_offset, file);
2062
2063     if (is_declptr(type))
2064     {
2065         unsigned char flag = is_conformant_array(type) ? 0 : RPC_FC_P_SIMPLEPOINTER;
2066         int pointer_type = get_pointer_fc(type, attrs, toplevel_param);
2067         if (!pointer_type)
2068             pointer_type = RPC_FC_RP;
2069         print_start_tfs_comment(file, type, *typestring_offset);
2070         print_file(file, 2,"0x%x, 0x%x,\t/* %s%s */\n",
2071                    pointer_type, flag, string_of_type(pointer_type),
2072                    flag ? " [simple_pointer]" : "");
2073         *typestring_offset += 2;
2074         if (!flag)
2075         {
2076             print_file(file, 2, "NdrFcShort(0x2),\n");
2077             *typestring_offset += 2;
2078         }
2079     }
2080
2081     if (is_array(type))
2082         elem_type = type_array_get_element(type);
2083     else
2084         elem_type = type_pointer_get_ref(type);
2085
2086     if (type_get_type(elem_type) != TYPE_BASIC)
2087     {
2088         error("write_string_tfs: Unimplemented for non-basic type %s\n", name);
2089         return start_offset;
2090     }
2091
2092     rtype = get_basic_fc(elem_type);
2093     if ((rtype != RPC_FC_BYTE) && (rtype != RPC_FC_CHAR) && (rtype != RPC_FC_WCHAR))
2094     {
2095         error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", rtype, name);
2096         return start_offset;
2097     }
2098
2099     if (type_get_type(type) == TYPE_ARRAY && !type_array_has_conformance(type))
2100     {
2101         unsigned int dim = type_array_get_dim(type);
2102
2103         /* FIXME: multi-dimensional array */
2104         if (0xffffu < dim)
2105             error("array size for parameter %s exceeds %u bytes by %u bytes\n",
2106                   name, 0xffffu, dim - 0xffffu);
2107
2108         if (rtype == RPC_FC_WCHAR)
2109             WRITE_FCTYPE(file, FC_WSTRING, *typestring_offset);
2110         else
2111             WRITE_FCTYPE(file, FC_CSTRING, *typestring_offset);
2112         print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
2113         *typestring_offset += 2;
2114
2115         print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", dim, dim);
2116         *typestring_offset += 2;
2117
2118         return start_offset;
2119     }
2120     else if (is_conformant_array(type))
2121     {
2122         unsigned int align = 0;
2123
2124         if (rtype == RPC_FC_WCHAR)
2125             WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
2126         else
2127             WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
2128         print_file(file, 2, "0x%x, /* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED);
2129         *typestring_offset += 2;
2130
2131         *typestring_offset += write_conf_or_var_desc(
2132             file, current_structure,
2133             (!type_array_is_decl_as_ptr(type) && current_structure
2134              ? type_memsize(current_structure, &align)
2135              : 0),
2136             type, type_array_get_conformance(type));
2137
2138         return start_offset;
2139     }
2140     else
2141     {
2142         if (rtype == RPC_FC_WCHAR)
2143             WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset);
2144         else
2145             WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset);
2146         print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
2147         *typestring_offset += 2;
2148
2149         return start_offset;
2150     }
2151 }
2152
2153 static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type,
2154                                     const char *name, unsigned int *typestring_offset)
2155 {
2156     const expr_t *length_is = type_array_get_variance(type);
2157     const expr_t *size_is = type_array_get_conformance(type);
2158     unsigned int align = 0;
2159     unsigned int size;
2160     unsigned int start_offset;
2161     unsigned char fc;
2162     int pointer_type = get_attrv(attrs, ATTR_POINTERTYPE);
2163     unsigned int baseoff
2164         = !type_array_is_decl_as_ptr(type) && current_structure
2165         ? type_memsize(current_structure, &align)
2166         : 0;
2167
2168     if (!pointer_type)
2169         pointer_type = RPC_FC_RP;
2170
2171     write_embedded_types(file, attrs, type_array_get_element(type), name, FALSE, typestring_offset);
2172
2173     align = 0;
2174     size = type_memsize((is_conformant_array(type) ? type_array_get_element(type) : type), &align);
2175     fc = get_array_fc(type);
2176
2177     start_offset = *typestring_offset;
2178     update_tfsoff(type, start_offset, file);
2179     print_start_tfs_comment(file, type, start_offset);
2180     print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc));
2181     print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
2182     *typestring_offset += 2;
2183
2184     align = 0;
2185     if (fc != RPC_FC_BOGUS_ARRAY)
2186     {
2187         if (fc == RPC_FC_LGFARRAY || fc == RPC_FC_LGVARRAY)
2188         {
2189             print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", size, size);
2190             *typestring_offset += 4;
2191         }
2192         else
2193         {
2194             print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", size, size);
2195             *typestring_offset += 2;
2196         }
2197
2198         if (is_conformant_array(type))
2199             *typestring_offset
2200                 += write_conf_or_var_desc(file, current_structure, baseoff,
2201                                           type, size_is);
2202
2203         if (fc == RPC_FC_SMVARRAY || fc == RPC_FC_LGVARRAY)
2204         {
2205             unsigned int elalign = 0;
2206             unsigned int elsize = type_memsize(type_array_get_element(type), &elalign);
2207             unsigned int dim = type_array_get_dim(type);
2208
2209             if (fc == RPC_FC_LGVARRAY)
2210             {
2211                 print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", dim, dim);
2212                 *typestring_offset += 4;
2213             }
2214             else
2215             {
2216                 print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", dim, dim);
2217                 *typestring_offset += 2;
2218             }
2219
2220             print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", elsize, elsize);
2221             *typestring_offset += 2;
2222         }
2223
2224         if (length_is)
2225             *typestring_offset
2226                 += write_conf_or_var_desc(file, current_structure, baseoff,
2227                                           type, length_is);
2228
2229         if (type_has_pointers(type_array_get_element(type)) &&
2230             (type_array_is_decl_as_ptr(type) || !current_structure))
2231         {
2232             print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
2233             print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
2234             *typestring_offset += 2;
2235             write_pointer_description(file, type, typestring_offset);
2236             print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
2237             *typestring_offset += 1;
2238         }
2239
2240         write_array_element_type(file, type, FALSE, typestring_offset);
2241         write_end(file, typestring_offset);
2242     }
2243     else
2244     {
2245         unsigned int dim = size_is ? 0 : type_array_get_dim(type);
2246         print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", dim, dim);
2247         *typestring_offset += 2;
2248         *typestring_offset
2249             += write_conf_or_var_desc(file, current_structure, baseoff,
2250                                       type, size_is);
2251         *typestring_offset
2252             += write_conf_or_var_desc(file, current_structure, baseoff,
2253                                       type, length_is);
2254
2255         write_array_element_type(file, type, TRUE, typestring_offset);
2256         write_end(file, typestring_offset);
2257     }
2258
2259     return start_offset;
2260 }
2261
2262 static const var_t *find_array_or_string_in_struct(const type_t *type)
2263 {
2264     const var_list_t *fields = type_struct_get_fields(type);
2265     const var_t *last_field;
2266     const type_t *ft;
2267
2268     if (!fields || list_empty(fields))
2269         return NULL;
2270
2271     last_field = LIST_ENTRY( list_tail(fields), const var_t, entry );
2272     ft = last_field->type;
2273
2274     if (is_conformant_array(ft) && !type_array_is_decl_as_ptr(ft))
2275         return last_field;
2276
2277     if (type_get_type(ft) == TYPE_STRUCT)
2278         return find_array_or_string_in_struct(ft);
2279     else
2280         return NULL;
2281 }
2282
2283 static void write_struct_members(FILE *file, const type_t *type,
2284                                  int is_complex, unsigned int *corroff,
2285                                  unsigned int *typestring_offset)
2286 {
2287     const var_t *field;
2288     unsigned short offset = 0;
2289     unsigned int salign = 1;
2290     int padding;
2291     var_list_t *fields = type_struct_get_fields(type);
2292
2293     if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
2294     {
2295         type_t *ft = field->type;
2296         unsigned int align = 0;
2297         unsigned int size = type_memsize(ft, &align);
2298         align = clamp_align(align);
2299         if (salign < align) salign = align;
2300
2301         if (!is_conformant_array(ft) || type_array_is_decl_as_ptr(ft))
2302         {
2303             if ((align - 1) & offset)
2304             {
2305                 unsigned char fc = 0;
2306                 switch (align)
2307                 {
2308                 case 2:
2309                     fc = RPC_FC_ALIGNM2;
2310                     break;
2311                 case 4:
2312                     fc = RPC_FC_ALIGNM4;
2313                     break;
2314                 case 8:
2315                     fc = RPC_FC_ALIGNM8;
2316                     break;
2317                 default:
2318                     error("write_struct_members: cannot align type %d\n", type_get_type(ft));
2319                 }
2320                 print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
2321                 offset = ROUND_SIZE(offset, align);
2322                 *typestring_offset += 1;
2323             }
2324             write_member_type(file, type, is_complex, field->attrs, field->type, corroff,
2325                               typestring_offset);
2326             offset += size;
2327         }
2328     }
2329
2330     padding = ROUNDING(offset, salign);
2331     if (padding)
2332     {
2333         print_file(file, 2, "0x%x,\t/* FC_STRUCTPAD%d */\n",
2334                    RPC_FC_STRUCTPAD1 + padding - 1,
2335                    padding);
2336         *typestring_offset += 1;
2337     }
2338
2339     write_end(file, typestring_offset);
2340 }
2341
2342 static unsigned int write_struct_tfs(FILE *file, type_t *type,
2343                                      const char *name, unsigned int *tfsoff)
2344 {
2345     const type_t *save_current_structure = current_structure;
2346     unsigned int total_size;
2347     const var_t *array;
2348     unsigned int start_offset;
2349     unsigned int array_offset;
2350     unsigned int align = 0;
2351     unsigned int corroff;
2352     var_t *f;
2353     unsigned char fc = get_struct_fc(type);
2354     var_list_t *fields = type_struct_get_fields(type);
2355
2356     guard_rec(type);
2357     current_structure = type;
2358
2359     total_size = type_memsize(type, &align);
2360     if (total_size > USHRT_MAX)
2361         error("structure size for %s exceeds %d bytes by %d bytes\n",
2362               name, USHRT_MAX, total_size - USHRT_MAX);
2363
2364     if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
2365         write_embedded_types(file, f->attrs, f->type, f->name, FALSE, tfsoff);
2366
2367     array = find_array_or_string_in_struct(type);
2368     if (array && !processed(array->type))
2369         array_offset
2370             = is_string_type(array->attrs, array->type)
2371             ? write_string_tfs(file, array->attrs, array->type, FALSE, array->name, tfsoff)
2372             : write_array_tfs(file, array->attrs, array->type, array->name, tfsoff);
2373
2374     corroff = *tfsoff;
2375     write_descriptors(file, type, tfsoff);
2376
2377     start_offset = *tfsoff;
2378     update_tfsoff(type, start_offset, file);
2379     print_start_tfs_comment(file, type, start_offset);
2380     print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
2381     print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
2382     print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", total_size, total_size);
2383     *tfsoff += 4;
2384
2385     if (array)
2386     {
2387         unsigned int absoff = array->type->typestring_offset;
2388         short reloff = absoff - *tfsoff;
2389         print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n",
2390                    reloff, reloff, absoff);
2391         *tfsoff += 2;
2392     }
2393     else if (fc == RPC_FC_BOGUS_STRUCT)
2394     {
2395         print_file(file, 2, "NdrFcShort(0x0),\n");
2396         *tfsoff += 2;
2397     }
2398
2399     if (fc == RPC_FC_BOGUS_STRUCT)
2400     {
2401         /* On the sizing pass, type->ptrdesc may be zero, but it's ok as
2402            nothing is written to file yet.  On the actual writing pass,
2403            this will have been updated.  */
2404         unsigned int absoff = type->ptrdesc ? type->ptrdesc : *tfsoff;
2405         int reloff = absoff - *tfsoff;
2406         assert( reloff >= 0 );
2407         print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %d (%u) */\n",
2408                    reloff, reloff, absoff);
2409         *tfsoff += 2;
2410     }
2411     else if ((fc == RPC_FC_PSTRUCT) ||
2412              (fc == RPC_FC_CPSTRUCT) ||
2413              (fc == RPC_FC_CVSTRUCT && type_has_pointers(type)))
2414     {
2415         print_file(file, 2, "0x%x, /* FC_PP */\n", RPC_FC_PP);
2416         print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
2417         *tfsoff += 2;
2418         write_pointer_description(file, type, tfsoff);
2419         print_file(file, 2, "0x%x, /* FC_END */\n", RPC_FC_END);
2420         *tfsoff += 1;
2421     }
2422
2423     write_struct_members(file, type, fc == RPC_FC_BOGUS_STRUCT, &corroff,
2424                          tfsoff);
2425
2426     if (fc == RPC_FC_BOGUS_STRUCT)
2427     {
2428         const var_t *f;
2429
2430         type->ptrdesc = *tfsoff;
2431         if (fields) LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry)
2432         {
2433             type_t *ft = f->type;
2434             switch (typegen_detect_type(ft, f->attrs, TDT_IGNORE_STRINGS))
2435             {
2436             case TGT_POINTER:
2437                 if (is_string_type(f->attrs, ft))
2438                     write_string_tfs(file, f->attrs, ft, FALSE, f->name, tfsoff);
2439                 else
2440                     write_pointer_tfs(file, f->attrs, ft,
2441                                       type_pointer_get_ref(ft)->typestring_offset,
2442                                       FALSE, tfsoff);
2443                 break;
2444             case TGT_ARRAY:
2445                 if (type_array_is_decl_as_ptr(ft))
2446                 {
2447                     unsigned int offset;
2448
2449                     print_file(file, 0, "/* %d */\n", *tfsoff);
2450
2451                     offset = ft->typestring_offset;
2452                     /* skip over the pointer that is written for strings, since a
2453                      * pointer has to be written in-place here */
2454                     if (is_string_type(f->attrs, ft))
2455                         offset += 4;
2456                     write_nonsimple_pointer(file, f->attrs, ft, FALSE, offset, tfsoff);
2457                 }
2458                 break;
2459             default:
2460                 break;
2461             }
2462         }
2463         if (type->ptrdesc == *tfsoff)
2464             type->ptrdesc = 0;
2465     }
2466
2467     current_structure = save_current_structure;
2468     return start_offset;
2469 }
2470
2471 static void write_branch_type(FILE *file, const type_t *t, unsigned int *tfsoff)
2472 {
2473     if (t == NULL)
2474     {
2475         print_file(file, 2, "NdrFcShort(0x0),\t/* No type */\n");
2476     }
2477     else
2478     {
2479         if (type_get_type(t) == TYPE_BASIC || type_get_type(t) == TYPE_ENUM)
2480         {
2481             unsigned char fc;
2482             if (type_get_type(t) == TYPE_BASIC)
2483                 fc = get_basic_fc(t);
2484             else
2485                 fc = get_enum_fc(t);
2486             print_file(file, 2, "NdrFcShort(0x80%02x),\t/* Simple arm type: %s */\n",
2487                        fc, string_of_type(fc));
2488         }
2489         else if (t->typestring_offset)
2490         {
2491             short reloff = t->typestring_offset - *tfsoff;
2492             print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %d (%d) */\n",
2493                        reloff, reloff, t->typestring_offset);
2494         }
2495         else
2496             error("write_branch_type: type unimplemented %d\n", type_get_type(t));
2497     }
2498
2499     *tfsoff += 2;
2500 }
2501
2502 static unsigned int write_union_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
2503 {
2504     unsigned int align;
2505     unsigned int start_offset;
2506     unsigned int size;
2507     var_list_t *fields;
2508     unsigned int nbranch = 0;
2509     type_t *deftype = NULL;
2510     short nodeftype = 0xffff;
2511     var_t *f;
2512
2513     guard_rec(type);
2514
2515     align = 0;
2516     size = type_memsize(type, &align);
2517
2518     fields = type_union_get_cases(type);
2519
2520     if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
2521     {
2522         expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE);
2523         if (cases)
2524             nbranch += list_count(cases);
2525         if (f->type)
2526             write_embedded_types(file, f->attrs, f->type, f->name, TRUE, tfsoff);
2527     }
2528
2529     start_offset = *tfsoff;
2530     update_tfsoff(type, start_offset, file);
2531     print_start_tfs_comment(file, type, start_offset);
2532     if (type_get_type(type) == TYPE_ENCAPSULATED_UNION)
2533     {
2534         const var_t *sv = type_union_get_switch_value(type);
2535         const type_t *st = sv->type;
2536         unsigned char fc;
2537
2538         if (type_get_type(st) == TYPE_BASIC)
2539         {
2540             switch (get_basic_fc(st))
2541             {
2542             case RPC_FC_CHAR:
2543             case RPC_FC_SMALL:
2544             case RPC_FC_BYTE:
2545             case RPC_FC_USMALL:
2546             case RPC_FC_WCHAR:
2547             case RPC_FC_SHORT:
2548             case RPC_FC_USHORT:
2549             case RPC_FC_LONG:
2550             case RPC_FC_ULONG:
2551                 fc = get_basic_fc(st);
2552                 break;
2553             default:
2554                 fc = 0;
2555                 error("union switch type must be an integer, char, or enum\n");
2556             }
2557         }
2558         else if (type_get_type(st) == TYPE_ENUM)
2559             fc = get_enum_fc(st);
2560         else
2561             error("union switch type must be an integer, char, or enum\n");
2562
2563         print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", RPC_FC_ENCAPSULATED_UNION);
2564         print_file(file, 2, "0x%x,\t/* Switch type= %s */\n",
2565                    0x40 | fc, string_of_type(fc));
2566         *tfsoff += 2;
2567     }
2568     else if (is_attr(type->attrs, ATTR_SWITCHTYPE))
2569     {
2570         static const expr_t dummy_expr;  /* FIXME */
2571         const type_t *st = get_attrp(type->attrs, ATTR_SWITCHTYPE);
2572         unsigned char fc;
2573
2574         if (type_get_type(st) == TYPE_BASIC)
2575         {
2576             switch (get_basic_fc(st))
2577             {
2578             case RPC_FC_CHAR:
2579             case RPC_FC_SMALL:
2580             case RPC_FC_USMALL:
2581             case RPC_FC_SHORT:
2582             case RPC_FC_USHORT:
2583             case RPC_FC_LONG:
2584             case RPC_FC_ULONG:
2585             case RPC_FC_ENUM16:
2586             case RPC_FC_ENUM32:
2587                 fc = get_basic_fc(st);
2588                 break;
2589             default:
2590                 fc = 0;
2591                 error("union switch type must be an integer, char, or enum\n");
2592             }
2593         }
2594         else if (type_get_type(st) == TYPE_ENUM)
2595             fc = get_enum_fc(st);
2596         else
2597             error("union switch type must be an integer, char, or enum\n");
2598
2599         print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION);
2600         print_file(file, 2, "0x%x,\t/* Switch type= %s */\n",
2601                    fc, string_of_type(fc));
2602         *tfsoff += 2;
2603
2604         *tfsoff += write_conf_or_var_desc(file, NULL, *tfsoff, st, &dummy_expr );
2605         print_file(file, 2, "NdrFcShort(0x2),\t/* Offset= 2 (%u) */\n", *tfsoff + 2);
2606         *tfsoff += 2;
2607         print_file(file, 0, "/* %u */\n", *tfsoff);
2608     }
2609
2610     print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", size, size);
2611     print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", nbranch, nbranch);
2612     *tfsoff += 4;
2613
2614     if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
2615     {
2616         type_t *ft = f->type;
2617         expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE);
2618         int deflt = is_attr(f->attrs, ATTR_DEFAULT);
2619         expr_t *c;
2620
2621         if (cases == NULL && !deflt)
2622             error("union field %s with neither case nor default attribute\n", f->name);
2623
2624         if (cases) LIST_FOR_EACH_ENTRY(c, cases, expr_t, entry)
2625         {
2626             /* MIDL doesn't check for duplicate cases, even though that seems
2627                like a reasonable thing to do, it just dumps them to the TFS
2628                like we're going to do here.  */
2629             print_file(file, 2, "NdrFcLong(0x%lx),\t/* %ld */\n", c->cval, c->cval);
2630             *tfsoff += 4;
2631             write_branch_type(file, ft, tfsoff);
2632         }
2633
2634         /* MIDL allows multiple default branches, even though that seems
2635            illogical, it just chooses the last one, which is what we will
2636            do.  */
2637         if (deflt)
2638         {
2639             deftype = ft;
2640             nodeftype = 0;
2641         }
2642     }
2643
2644     if (deftype)
2645     {
2646         write_branch_type(file, deftype, tfsoff);
2647     }
2648     else
2649     {
2650         print_file(file, 2, "NdrFcShort(0x%hx),\n", nodeftype);
2651         *tfsoff += 2;
2652     }
2653
2654     return start_offset;
2655 }
2656
2657 static unsigned int write_ip_tfs(FILE *file, const attr_list_t *attrs, type_t *type,
2658                                  unsigned int *typeformat_offset)
2659 {
2660     unsigned int i;
2661     unsigned int start_offset = *typeformat_offset;
2662     expr_t *iid = get_attrp(attrs, ATTR_IIDIS);
2663
2664     print_start_tfs_comment(file, type, start_offset);
2665
2666     if (iid)
2667     {
2668         print_file(file, 2, "0x2f,  /* FC_IP */\n");
2669         print_file(file, 2, "0x5c,  /* FC_PAD */\n");
2670         *typeformat_offset
2671             += write_conf_or_var_desc(file, current_structure, 0, type, iid) + 2;
2672     }
2673     else
2674     {
2675         const type_t *base = is_ptr(type) ? type_pointer_get_ref(type) : type;
2676         const UUID *uuid = get_attrp(base->attrs, ATTR_UUID);
2677
2678         if (! uuid)
2679             error("%s: interface %s missing UUID\n", __FUNCTION__, base->name);
2680
2681         update_tfsoff(type, start_offset, file);
2682         print_file(file, 2, "0x2f,\t/* FC_IP */\n");
2683         print_file(file, 2, "0x5a,\t/* FC_CONSTANT_IID */\n");
2684         print_file(file, 2, "NdrFcLong(0x%08x),\n", uuid->Data1);
2685         print_file(file, 2, "NdrFcShort(0x%04x),\n", uuid->Data2);
2686         print_file(file, 2, "NdrFcShort(0x%04x),\n", uuid->Data3);
2687         for (i = 0; i < 8; ++i)
2688             print_file(file, 2, "0x%02x,\n", uuid->Data4[i]);
2689
2690         if (file)
2691             fprintf(file, "\n");
2692
2693         *typeformat_offset += 18;
2694     }
2695     return start_offset;
2696 }
2697
2698 static unsigned int write_contexthandle_tfs(FILE *file,
2699                                             const attr_list_t *attrs,
2700                                             const type_t *type,
2701                                             unsigned int *typeformat_offset)
2702 {
2703     unsigned int start_offset = *typeformat_offset;
2704     unsigned char flags = 0;
2705
2706     if (is_attr(current_iface->attrs, ATTR_STRICTCONTEXTHANDLE))
2707         flags |= NDR_STRICT_CONTEXT_HANDLE;
2708
2709     if (is_ptr(type))
2710         flags |= 0x80;
2711     if (is_attr(attrs, ATTR_IN))
2712     {
2713         flags |= 0x40;
2714         if (!is_attr(attrs, ATTR_OUT))
2715             flags |= NDR_CONTEXT_HANDLE_CANNOT_BE_NULL;
2716     }
2717     if (is_attr(attrs, ATTR_OUT))
2718         flags |= 0x20;
2719
2720     WRITE_FCTYPE(file, FC_BIND_CONTEXT, *typeformat_offset);
2721     print_file(file, 2, "0x%x,\t/* Context flags: ", flags);
2722     /* return and can't be null values overlap */
2723     if (((flags & 0x21) != 0x21) && (flags & NDR_CONTEXT_HANDLE_CANNOT_BE_NULL))
2724         print_file(file, 0, "can't be null, ");
2725     if (flags & NDR_CONTEXT_HANDLE_SERIALIZE)
2726         print_file(file, 0, "serialize, ");
2727     if (flags & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
2728         print_file(file, 0, "no serialize, ");
2729     if (flags & NDR_STRICT_CONTEXT_HANDLE)
2730         print_file(file, 0, "strict, ");
2731     if ((flags & 0x21) == 0x20)
2732         print_file(file, 0, "out, ");
2733     if ((flags & 0x21) == 0x21)
2734         print_file(file, 0, "return, ");
2735     if (flags & 0x40)
2736         print_file(file, 0, "in, ");
2737     if (flags & 0x80)
2738         print_file(file, 0, "via ptr, ");
2739     print_file(file, 0, "*/\n");
2740     print_file(file, 2, "0, /* FIXME: rundown routine index*/\n");
2741     print_file(file, 2, "0, /* FIXME: param num */\n");
2742     *typeformat_offset += 4;
2743
2744     return start_offset;
2745 }
2746
2747 static unsigned int write_range_tfs(FILE *file, const attr_list_t *attrs,
2748                                     type_t *type, expr_list_t *range_list,
2749                                     unsigned int *typeformat_offset)
2750 {
2751     unsigned char fc;
2752     unsigned int start_offset = *typeformat_offset;
2753     const expr_t *range_min = LIST_ENTRY(list_head(range_list), const expr_t, entry);
2754     const expr_t *range_max = LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
2755
2756     if (type_get_type(type) == TYPE_BASIC)
2757         fc = get_basic_fc(type);
2758     else
2759         fc = get_enum_fc(type);
2760
2761     /* fc must fit in lower 4-bits of 8-bit field below */
2762     assert(fc <= 0xf);
2763
2764     print_file(file, 0, "/* %u */\n", *typeformat_offset);
2765     print_file(file, 2, "0x%x,\t/* FC_RANGE */\n", RPC_FC_RANGE);
2766     print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
2767     print_file(file, 2, "NdrFcLong(0x%lx),\t/* %lu */\n", range_min->cval, range_min->cval);
2768     print_file(file, 2, "NdrFcLong(0x%lx),\t/* %lu */\n", range_max->cval, range_max->cval);
2769     *typeformat_offset += 10;
2770
2771     return start_offset;
2772 }
2773
2774 static unsigned int write_type_tfs(FILE *file, int indent,
2775                                    const attr_list_t *attrs, type_t *type,
2776                                    const char *name,
2777                                    enum type_context context,
2778                                    unsigned int *typeformat_offset)
2779 {
2780     unsigned int offset;
2781
2782     switch (typegen_detect_type(type, attrs, TDT_ALL_TYPES))
2783     {
2784     case TGT_CTXT_HANDLE:
2785     case TGT_CTXT_HANDLE_POINTER:
2786         return write_contexthandle_tfs(file, attrs, type, typeformat_offset);
2787     case TGT_USER_TYPE:
2788         write_user_tfs(file, type, typeformat_offset);
2789         return type->typestring_offset;
2790     case TGT_STRING:
2791         return write_string_tfs(file, attrs, type,
2792                                 context == TYPE_CONTEXT_TOPLEVELPARAM,
2793                                 name, typeformat_offset);
2794     case TGT_ARRAY:
2795     {
2796         unsigned int off;
2797         /* conformant and pointer arrays are handled specially */
2798         if ((context != TYPE_CONTEXT_CONTAINER &&
2799              context != TYPE_CONTEXT_CONTAINER_NO_POINTERS) ||
2800             !is_conformant_array(type) || type_array_is_decl_as_ptr(type))
2801             off = write_array_tfs(file, attrs, type, name, typeformat_offset);
2802         else
2803             off = 0;
2804         if (context != TYPE_CONTEXT_CONTAINER &&
2805             context != TYPE_CONTEXT_CONTAINER_NO_POINTERS)
2806         {
2807             int ptr_type;
2808             ptr_type = get_pointer_fc(type, attrs,
2809                                       context == TYPE_CONTEXT_TOPLEVELPARAM);
2810             if (ptr_type != RPC_FC_RP)
2811             {
2812                 unsigned int absoff = type->typestring_offset;
2813                 short reloff = absoff - (*typeformat_offset + 2);
2814                 off = *typeformat_offset;
2815                 print_file(file, 0, "/* %d */\n", off);
2816                 print_file(file, 2, "0x%x, 0x0,\t/* %s */\n", ptr_type,
2817                            string_of_type(ptr_type));
2818                 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n",
2819                            reloff, reloff, absoff);
2820                 *typeformat_offset += 4;
2821             }
2822         }
2823         return off;
2824     }
2825     case TGT_STRUCT:
2826         if (processed(type)) return type->typestring_offset;
2827         return write_struct_tfs(file, type, name, typeformat_offset);
2828     case TGT_UNION:
2829         if (processed(type)) return type->typestring_offset;
2830         return write_union_tfs(file, type, typeformat_offset);
2831     case TGT_ENUM:
2832     case TGT_BASIC:
2833         /* nothing to do */
2834         return 0;
2835     case TGT_RANGE:
2836     {
2837         expr_list_t *range_list = get_attrp(attrs, ATTR_RANGE);
2838         if (!range_list)
2839             range_list = get_aliaschain_attrp(type, ATTR_RANGE);
2840         return write_range_tfs(file, attrs, type, range_list, typeformat_offset);
2841     }
2842     case TGT_IFACE_POINTER:
2843         return write_ip_tfs(file, attrs, type, typeformat_offset);
2844     case TGT_POINTER:
2845         if (processed(type_pointer_get_ref(type)))
2846             offset = type_pointer_get_ref(type)->typestring_offset;
2847         else
2848         {
2849             enum type_context ref_context;
2850             if (context == TYPE_CONTEXT_TOPLEVELPARAM)
2851                 ref_context = TYPE_CONTEXT_PARAM;
2852             else if (context == TYPE_CONTEXT_CONTAINER_NO_POINTERS)
2853                 ref_context = TYPE_CONTEXT_CONTAINER;
2854             else
2855                 ref_context = context;
2856             offset = write_type_tfs(
2857                 file, indent, attrs, type_pointer_get_ref(type), name,
2858                 ref_context, typeformat_offset);
2859         }
2860         if (context == TYPE_CONTEXT_CONTAINER_NO_POINTERS)
2861             return 0;
2862         else
2863             return write_pointer_tfs(file, attrs, type, offset,
2864                                      context == TYPE_CONTEXT_TOPLEVELPARAM,
2865                                      typeformat_offset);
2866     case TGT_INVALID:
2867         break;
2868     }
2869     error("invalid type %s for var %s\n", type->name, name);
2870     return 0;
2871 }
2872
2873 static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
2874                                 const char *name, int write_ptr, unsigned int *tfsoff)
2875 {
2876     return write_type_tfs(file, 2, attrs, type, name, write_ptr ? TYPE_CONTEXT_CONTAINER : TYPE_CONTEXT_CONTAINER_NO_POINTERS, tfsoff);
2877 }
2878
2879 static unsigned int process_tfs_stmts(FILE *file, const statement_list_t *stmts,
2880                                       type_pred_t pred, unsigned int *typeformat_offset)
2881 {
2882     const var_t *var;
2883     const statement_t *stmt;
2884
2885     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
2886     {
2887         const type_t *iface;
2888         const statement_t *stmt_func;
2889
2890         if (stmt->type == STMT_LIBRARY)
2891         {
2892             process_tfs_stmts(file, stmt->u.lib->stmts, pred, typeformat_offset);
2893             continue;
2894         }
2895         else if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE)
2896             continue;
2897
2898         iface = stmt->u.type;
2899         if (!pred(iface))
2900             continue;
2901
2902         current_iface = iface;
2903         STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(iface) )
2904         {
2905             const var_t *func = stmt_func->u.var;
2906                 if (is_local(func->attrs)) continue;
2907
2908                 if (!is_void(type_function_get_rettype(func->type)))
2909                 {
2910                     update_tfsoff(type_function_get_rettype(func->type),
2911                                   write_type_tfs(
2912                                       file, 2, func->attrs,
2913                                       type_function_get_rettype(func->type),
2914                                       func->name, TYPE_CONTEXT_PARAM,
2915                                       typeformat_offset),
2916                                   file);
2917                 }
2918
2919                 current_func = func;
2920                 if (type_get_function_args(func->type))
2921                     LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
2922                         update_tfsoff(
2923                             var->type,
2924                             write_type_tfs(
2925                                 file, 2, var->attrs, var->type, var->name,
2926                                 TYPE_CONTEXT_TOPLEVELPARAM,
2927                                 typeformat_offset),
2928                             file);
2929         }
2930     }
2931
2932     return *typeformat_offset + 1;
2933 }
2934
2935 static unsigned int process_tfs(FILE *file, const statement_list_t *stmts, type_pred_t pred)
2936 {
2937     unsigned int typeformat_offset = 2;
2938
2939     return process_tfs_stmts(file, stmts, pred, &typeformat_offset);
2940 }
2941
2942
2943 void write_typeformatstring(FILE *file, const statement_list_t *stmts, type_pred_t pred)
2944 {
2945     int indent = 0;
2946
2947     print_file(file, indent, "static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
2948     print_file(file, indent, "{\n");
2949     indent++;
2950     print_file(file, indent, "0,\n");
2951     print_file(file, indent, "{\n");
2952     indent++;
2953     print_file(file, indent, "NdrFcShort(0x0),\n");
2954
2955     set_all_tfswrite(TRUE);
2956     process_tfs(file, stmts, pred);
2957
2958     print_file(file, indent, "0x0\n");
2959     indent--;
2960     print_file(file, indent, "}\n");
2961     indent--;
2962     print_file(file, indent, "};\n");
2963     print_file(file, indent, "\n");
2964 }
2965
2966 static unsigned int get_required_buffer_size_type(
2967     const type_t *type, const char *name, const attr_list_t *attrs, int toplevel_param, unsigned int *alignment)
2968 {
2969     *alignment = 0;
2970     switch (typegen_detect_type(type, NULL, TDT_IGNORE_STRINGS|TDT_IGNORE_RANGES))
2971     {
2972     case TGT_USER_TYPE:
2973     {
2974         const char *uname;
2975         const type_t *utype = get_user_type(type, &uname);
2976         return get_required_buffer_size_type(utype, uname, NULL, FALSE, alignment);
2977     }
2978     case TGT_BASIC:
2979         switch (get_basic_fc(type))
2980         {
2981         case RPC_FC_BYTE:
2982         case RPC_FC_CHAR:
2983         case RPC_FC_USMALL:
2984         case RPC_FC_SMALL:
2985             *alignment = 4;
2986             return 1;
2987
2988         case RPC_FC_WCHAR:
2989         case RPC_FC_USHORT:
2990         case RPC_FC_SHORT:
2991             *alignment = 4;
2992             return 2;
2993
2994         case RPC_FC_ULONG:
2995         case RPC_FC_LONG:
2996         case RPC_FC_FLOAT:
2997         case RPC_FC_ERROR_STATUS_T:
2998             *alignment = 4;
2999             return 4;
3000
3001         case RPC_FC_HYPER:
3002         case RPC_FC_DOUBLE:
3003             *alignment = 8;
3004             return 8;
3005
3006         case RPC_FC_INT3264:
3007         case RPC_FC_UINT3264:
3008             assert( pointer_size );
3009             *alignment = pointer_size;
3010             return pointer_size;
3011
3012         case RPC_FC_IGNORE:
3013         case RPC_FC_BIND_PRIMITIVE:
3014             return 0;
3015
3016         default:
3017             error("get_required_buffer_size: unknown basic type 0x%02x\n",
3018                   get_basic_fc(type));
3019             return 0;
3020         }
3021         break;
3022
3023     case TGT_ENUM:
3024         switch (get_enum_fc(type))
3025         {
3026         case RPC_FC_ENUM32:
3027             *alignment = 4;
3028             return 4;
3029         case RPC_FC_ENUM16:
3030             *alignment = 4;
3031             return 2;
3032         }
3033         break;
3034
3035     case TGT_STRUCT:
3036         if (get_struct_fc(type) == RPC_FC_STRUCT)
3037         {
3038             if (!type_struct_get_fields(type)) return 0;
3039             return fields_memsize(type_struct_get_fields(type), alignment);
3040         }
3041         break;
3042
3043     case TGT_POINTER:
3044         if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_RP)
3045         {
3046             const type_t *ref = type_pointer_get_ref(type);
3047             switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES))
3048             {
3049             case TGT_BASIC:
3050             case TGT_ENUM:
3051             case TGT_RANGE:
3052                 return get_required_buffer_size_type( ref, name, NULL, FALSE, alignment );
3053             case TGT_STRUCT:
3054                 if (get_struct_fc(ref) == RPC_FC_STRUCT)
3055                     return get_required_buffer_size_type( ref, name, NULL, FALSE, alignment );
3056                 break;
3057             case TGT_USER_TYPE:
3058             case TGT_CTXT_HANDLE:
3059             case TGT_CTXT_HANDLE_POINTER:
3060             case TGT_STRING:
3061             case TGT_POINTER:
3062             case TGT_ARRAY:
3063             case TGT_IFACE_POINTER:
3064             case TGT_UNION:
3065             case TGT_INVALID:
3066                 break;
3067             }
3068         }
3069         break;
3070
3071     case TGT_ARRAY:
3072         /* FIXME: depends on pointer type */
3073         return type_array_get_dim(type) *
3074             get_required_buffer_size_type(type_array_get_element(type), name, NULL, FALSE, alignment);
3075
3076     default:
3077         break;
3078     }
3079     return 0;
3080 }
3081
3082 static unsigned int get_required_buffer_size(const var_t *var, unsigned int *alignment, enum pass pass)
3083 {
3084     int in_attr = is_attr(var->attrs, ATTR_IN);
3085     int out_attr = is_attr(var->attrs, ATTR_OUT);
3086
3087     if (!in_attr && !out_attr)
3088         in_attr = 1;
3089
3090     *alignment = 0;
3091
3092     if ((pass == PASS_IN && in_attr) || (pass == PASS_OUT && out_attr) ||
3093         pass == PASS_RETURN)
3094     {
3095         if (is_ptrchain_attr(var, ATTR_CONTEXTHANDLE))
3096         {
3097             *alignment = 4;
3098             return 20;
3099         }
3100
3101         if (!is_string_type(var->attrs, var->type))
3102             return get_required_buffer_size_type(var->type, var->name,
3103                                                  var->attrs, TRUE, alignment);
3104     }
3105     return 0;
3106 }
3107
3108 static unsigned int get_function_buffer_size( const var_t *func, enum pass pass )
3109 {
3110     const var_t *var;
3111     unsigned int total_size = 0, alignment;
3112
3113     if (type_get_function_args(func->type))
3114     {
3115         LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
3116         {
3117             total_size += get_required_buffer_size(var, &alignment, pass);
3118             total_size += alignment;
3119         }
3120     }
3121
3122     if (pass == PASS_OUT && !is_void(type_function_get_rettype(func->type)))
3123     {
3124         var_t v = *func;
3125         v.type = type_function_get_rettype(func->type);
3126         total_size += get_required_buffer_size(&v, &alignment, PASS_RETURN);
3127         total_size += alignment;
3128     }
3129     return total_size;
3130 }
3131
3132 static void print_phase_function(FILE *file, int indent, const char *type,
3133                                  const char *local_var_prefix, enum remoting_phase phase,
3134                                  const var_t *var, unsigned int type_offset)
3135 {
3136     const char *function;
3137     switch (phase)
3138     {
3139     case PHASE_BUFFERSIZE:
3140         function = "BufferSize";
3141         break;
3142     case PHASE_MARSHAL:
3143         function = "Marshall";
3144         break;
3145     case PHASE_UNMARSHAL:
3146         function = "Unmarshall";
3147         break;
3148     case PHASE_FREE:
3149         function = "Free";
3150         break;
3151     default:
3152         assert(0);
3153         return;
3154     }
3155
3156     print_file(file, indent, "Ndr%s%s(\n", type, function);
3157     indent++;
3158     print_file(file, indent, "&__frame->_StubMsg,\n");
3159     print_file(file, indent, "%s%s%s%s%s,\n",
3160                (phase == PHASE_UNMARSHAL) ? "(unsigned char **)" : "(unsigned char *)",
3161                (phase == PHASE_UNMARSHAL || decl_indirect(var->type)) ? "&" : "",
3162                local_var_prefix,
3163                (phase == PHASE_UNMARSHAL && decl_indirect(var->type)) ? "_p_" : "",
3164                var->name);
3165     print_file(file, indent, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n",
3166                type_offset, (phase == PHASE_UNMARSHAL) ? "," : ");");
3167     if (phase == PHASE_UNMARSHAL)
3168         print_file(file, indent, "0);\n");
3169     indent--;
3170 }
3171
3172 void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix,
3173                           enum remoting_phase phase, enum pass pass, const var_t *var,
3174                           const char *varname)
3175 {
3176     type_t *type = var->type;
3177     unsigned int size;
3178     unsigned int alignment = 0;
3179
3180     /* no work to do for other phases, buffer sizing is done elsewhere */
3181     if (phase != PHASE_MARSHAL && phase != PHASE_UNMARSHAL)
3182         return;
3183
3184     if (type_get_type(type) == TYPE_ENUM ||
3185         (type_get_type(type) == TYPE_BASIC &&
3186          type_basic_get_type(type) == TYPE_BASIC_INT3264 &&
3187          pointer_size != 4))
3188     {
3189         unsigned char fc;
3190
3191         if (type_get_type(type) == TYPE_ENUM)
3192             fc = get_enum_fc(type);
3193         else
3194             fc = get_basic_fc(type);
3195
3196         if (phase == PHASE_MARSHAL)
3197             print_file(file, indent, "NdrSimpleTypeMarshall(\n");
3198         else
3199             print_file(file, indent, "NdrSimpleTypeUnmarshall(\n");
3200         print_file(file, indent+1, "&__frame->_StubMsg,\n");
3201         print_file(file, indent+1, "(unsigned char *)&%s%s,\n",
3202                    local_var_prefix,
3203                    var->name);
3204         print_file(file, indent+1, "0x%02x /* %s */);\n", fc, string_of_type(fc));
3205     }
3206     else
3207     {
3208         const type_t *ref = is_ptr(type) ? type_pointer_get_ref(type) : type;
3209         switch (get_basic_fc(ref))
3210         {
3211         case RPC_FC_BYTE:
3212         case RPC_FC_CHAR:
3213         case RPC_FC_SMALL:
3214         case RPC_FC_USMALL:
3215             size = 1;
3216             alignment = 1;
3217             break;
3218
3219         case RPC_FC_WCHAR:
3220         case RPC_FC_USHORT:
3221         case RPC_FC_SHORT:
3222             size = 2;
3223             alignment = 2;
3224             break;
3225
3226         case RPC_FC_ULONG:
3227         case RPC_FC_LONG:
3228         case RPC_FC_FLOAT:
3229         case RPC_FC_ERROR_STATUS_T:
3230         /* pointer_size must be 4 if we got here in these two cases */
3231         case RPC_FC_INT3264:
3232         case RPC_FC_UINT3264:
3233             size = 4;
3234             alignment = 4;
3235             break;
3236
3237         case RPC_FC_HYPER:
3238         case RPC_FC_DOUBLE:
3239             size = 8;
3240             alignment = 8;
3241             break;
3242
3243         case RPC_FC_IGNORE:
3244         case RPC_FC_BIND_PRIMITIVE:
3245             /* no marshalling needed */
3246             return;
3247
3248         default:
3249             error("print_phase_basetype: Unsupported type: %s (0x%02x, ptr_level: 0)\n",
3250                   var->name, get_basic_fc(ref));
3251             size = 0;
3252         }
3253
3254         if (phase == PHASE_MARSHAL && alignment > 1)
3255             print_file(file, indent, "MIDL_memset(__frame->_StubMsg.Buffer, 0, (0x%x - (ULONG_PTR)__frame->_StubMsg.Buffer) & 0x%x);\n", alignment, alignment - 1);
3256         print_file(file, indent, "__frame->_StubMsg.Buffer = (unsigned char *)(((ULONG_PTR)__frame->_StubMsg.Buffer + %u) & ~0x%x);\n",
3257                     alignment - 1, alignment - 1);
3258
3259         if (phase == PHASE_MARSHAL)
3260         {
3261             print_file(file, indent, "*(");
3262             write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
3263             if (is_ptr(type))
3264                 fprintf(file, " *)__frame->_StubMsg.Buffer = *");
3265             else
3266                 fprintf(file, " *)__frame->_StubMsg.Buffer = ");
3267             fprintf(file, "%s%s", local_var_prefix, varname);
3268             fprintf(file, ";\n");
3269         }
3270         else if (phase == PHASE_UNMARSHAL)
3271         {
3272             print_file(file, indent, "if (__frame->_StubMsg.Buffer + sizeof(");
3273             write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
3274             fprintf(file, ") > __frame->_StubMsg.BufferEnd)\n");
3275             print_file(file, indent, "{\n");
3276             print_file(file, indent + 1, "RpcRaiseException(RPC_X_BAD_STUB_DATA);\n");
3277             print_file(file, indent, "}\n");
3278             print_file(file, indent, "%s%s%s",
3279                        (pass == PASS_IN || pass == PASS_RETURN) ? "" : "*",
3280                        local_var_prefix, varname);
3281             if (pass == PASS_IN && is_ptr(type))
3282                 fprintf(file, " = (");
3283             else
3284                 fprintf(file, " = *(");
3285             write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
3286             fprintf(file, " *)__frame->_StubMsg.Buffer;\n");
3287         }
3288
3289         print_file(file, indent, "__frame->_StubMsg.Buffer += sizeof(");
3290         write_type_decl(file, is_ptr(type) ? type_pointer_get_ref(type) : type, NULL);
3291         fprintf(file, ");\n");
3292     }
3293 }
3294
3295 /* returns whether the MaxCount, Offset or ActualCount members need to be
3296  * filled in for the specified phase */
3297 static inline int is_conformance_needed_for_phase(enum remoting_phase phase)
3298 {
3299     return (phase != PHASE_UNMARSHAL);
3300 }
3301
3302 expr_t *get_size_is_expr(const type_t *t, const char *name)
3303 {
3304     expr_t *x = NULL;
3305
3306     for ( ; is_array(t); t = type_array_get_element(t))
3307         if (type_array_has_conformance(t))
3308         {
3309             if (!x)
3310                 x = type_array_get_conformance(t);
3311             else
3312                 error("%s: multidimensional conformant"
3313                       " arrays not supported at the top level\n",
3314                       name);
3315         }
3316
3317     return x;
3318 }
3319
3320 static void write_parameter_conf_or_var_exprs(FILE *file, int indent, const char *local_var_prefix,
3321                                               enum remoting_phase phase, const var_t *var)
3322 {
3323     const type_t *type = var->type;
3324     /* get fundamental type for the argument */
3325     for (;;)
3326     {
3327         switch (typegen_detect_type(type, var->attrs, TDT_IGNORE_STRINGS|TDT_IGNORE_RANGES))
3328         {
3329         case TGT_ARRAY:
3330             if (is_conformance_needed_for_phase(phase))
3331             {
3332                 if (type_array_has_conformance(type))
3333                 {
3334                     print_file(file, indent, "__frame->_StubMsg.MaxCount = (ULONG_PTR)");
3335                     write_expr(file, type_array_get_conformance(type), 1, 1, NULL, NULL, local_var_prefix);
3336                     fprintf(file, ";\n\n");
3337                 }
3338                 if (type_array_has_variance(type))
3339                 {
3340                     print_file(file, indent, "__frame->_StubMsg.Offset = 0;\n"); /* FIXME */
3341                     print_file(file, indent, "__frame->_StubMsg.ActualCount = (ULONG_PTR)");
3342                     write_expr(file, type_array_get_variance(type), 1, 1, NULL, NULL, local_var_prefix);
3343                     fprintf(file, ";\n\n");
3344                 }
3345             }
3346             break;
3347         case TGT_UNION:
3348             if (type_get_type(type) == TYPE_UNION &&
3349                 is_conformance_needed_for_phase(phase))
3350             {
3351                 print_file(file, indent, "__frame->_StubMsg.MaxCount = (ULONG_PTR)");
3352                 write_expr(file, get_attrp(var->attrs, ATTR_SWITCHIS), 1, 1, NULL, NULL, local_var_prefix);
3353                 fprintf(file, ";\n\n");
3354             }
3355             break;
3356         case TGT_IFACE_POINTER:
3357         {
3358             expr_t *iid;
3359
3360             if (is_conformance_needed_for_phase(phase) && (iid = get_attrp( var->attrs, ATTR_IIDIS )))
3361             {
3362                 print_file( file, indent, "__frame->_StubMsg.MaxCount = (ULONG_PTR) " );
3363                 write_expr( file, iid, 1, 1, NULL, NULL, local_var_prefix );
3364                 fprintf( file, ";\n\n" );
3365             }
3366             break;
3367         }
3368         case TGT_POINTER:
3369             type = type_pointer_get_ref(type);
3370             continue;
3371         case TGT_INVALID:
3372         case TGT_USER_TYPE:
3373         case TGT_CTXT_HANDLE:
3374         case TGT_CTXT_HANDLE_POINTER:
3375         case TGT_STRING:
3376         case TGT_BASIC:
3377         case TGT_ENUM:
3378         case TGT_STRUCT:
3379         case TGT_RANGE:
3380             break;
3381         }
3382         break;
3383     }
3384 }
3385
3386 static void write_remoting_arg(FILE *file, int indent, const var_t *func, const char *local_var_prefix,
3387                                enum pass pass, enum remoting_phase phase, const var_t *var)
3388 {
3389     int in_attr, out_attr, pointer_type;
3390     const type_t *type = var->type;
3391     unsigned int start_offset = type->typestring_offset;
3392
3393     if (is_ptr(type) || is_array(type))
3394         pointer_type = get_pointer_fc(type, var->attrs, pass != PASS_RETURN);
3395     else
3396         pointer_type = 0;
3397
3398     in_attr = is_attr(var->attrs, ATTR_IN);
3399     out_attr = is_attr(var->attrs, ATTR_OUT);
3400     if (!in_attr && !out_attr)
3401         in_attr = 1;
3402
3403     if (phase != PHASE_FREE)
3404         switch (pass)
3405         {
3406         case PASS_IN:
3407             if (!in_attr) return;
3408             break;
3409         case PASS_OUT:
3410             if (!out_attr) return;
3411             break;
3412         case PASS_RETURN:
3413             break;
3414         }
3415
3416     write_parameter_conf_or_var_exprs(file, indent, local_var_prefix, phase, var);
3417
3418     switch (typegen_detect_type(type, var->attrs, TDT_ALL_TYPES))
3419     {
3420     case TGT_CTXT_HANDLE:
3421     case TGT_CTXT_HANDLE_POINTER:
3422         if (phase == PHASE_MARSHAL)
3423         {
3424             if (pass == PASS_IN)
3425             {
3426                 /* if the context_handle attribute appears in the chain of types
3427                  * without pointers being followed, then the context handle must
3428                  * be direct, otherwise it is a pointer */
3429                 int is_ch_ptr = is_aliaschain_attr(type, ATTR_CONTEXTHANDLE) ? FALSE : TRUE;
3430                 print_file(file, indent, "NdrClientContextMarshall(\n");
3431                 print_file(file, indent + 1, "&__frame->_StubMsg,\n");
3432                 print_file(file, indent + 1, "(NDR_CCONTEXT)%s%s%s,\n", is_ch_ptr ? "*" : "", local_var_prefix, var->name);
3433                 print_file(file, indent + 1, "%s);\n", in_attr && out_attr ? "1" : "0");
3434             }
3435             else
3436             {
3437                 print_file(file, indent, "NdrServerContextNewMarshall(\n");
3438                 print_file(file, indent + 1, "&__frame->_StubMsg,\n");
3439                 print_file(file, indent + 1, "(NDR_SCONTEXT)%s%s,\n", local_var_prefix, var->name);
3440                 print_file(file, indent + 1, "(NDR_RUNDOWN)%s_rundown,\n", get_context_handle_type_name(var->type));
3441                 print_file(file, indent + 1, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]);\n", start_offset);
3442             }
3443         }
3444         else if (phase == PHASE_UNMARSHAL)
3445         {
3446             if (pass == PASS_OUT)
3447             {
3448                 if (!in_attr)
3449                     print_file(file, indent, "*%s%s = 0;\n", local_var_prefix, var->name);
3450                 print_file(file, indent, "NdrClientContextUnmarshall(\n");
3451                 print_file(file, indent + 1, "&__frame->_StubMsg,\n");
3452                 print_file(file, indent + 1, "(NDR_CCONTEXT *)%s%s,\n", local_var_prefix, var->name);
3453                 print_file(file, indent + 1, "__frame->_Handle);\n");
3454             }
3455             else
3456             {
3457                 print_file(file, indent, "%s%s = NdrServerContextNewUnmarshall(\n", local_var_prefix, var->name);
3458                 print_file(file, indent + 1, "&__frame->_StubMsg,\n");
3459                 print_file(file, indent + 1, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]);\n", start_offset);
3460             }
3461         }
3462         break;
3463     case TGT_USER_TYPE:
3464         print_phase_function(file, indent, "UserMarshal", local_var_prefix, phase, var, start_offset);
3465         break;
3466     case TGT_STRING:
3467         if (phase == PHASE_FREE || pass == PASS_RETURN ||
3468             pointer_type != RPC_FC_RP)
3469         {
3470             if (pointer_type == RPC_FC_RP && phase == PHASE_FREE &&
3471                 !in_attr && is_conformant_array(type))
3472             {
3473                 print_file(file, indent, "if (%s%s)\n", local_var_prefix, var->name);
3474                 indent++;
3475                 print_file(file, indent, "__frame->_StubMsg.pfnFree(%s%s);\n", local_var_prefix, var->name);
3476             }
3477             /* strings returned are assumed to be global and hence don't
3478              * need freeing */
3479             else if (is_declptr(type) &&
3480                      !(phase == PHASE_FREE && pass == PASS_RETURN))
3481                 print_phase_function(file, indent, "Pointer", local_var_prefix,
3482                                      phase, var, start_offset);
3483         }
3484         else
3485         {
3486             unsigned int real_start_offset = start_offset;
3487             /* skip over pointer description straight to string description */
3488             if (is_declptr(type))
3489             {
3490                 if (is_conformant_array(type))
3491                     real_start_offset += 4;
3492                 else
3493                     real_start_offset += 2;
3494             }
3495             if (is_array(type) && !is_conformant_array(type))
3496                 print_phase_function(file, indent, "NonConformantString",
3497                                      local_var_prefix, phase, var,
3498                                      real_start_offset);
3499             else
3500                 print_phase_function(file, indent, "ConformantString", local_var_prefix,
3501                                      phase, var, real_start_offset);
3502         }
3503         break;
3504     case TGT_ARRAY:
3505     {
3506         unsigned char tc = get_array_fc(type);
3507         const char *array_type = NULL;
3508
3509         /* We already have the size_is expression since it's at the
3510            top level, but do checks for multidimensional conformant
3511            arrays.  When we handle them, we'll need to extend this
3512            function to return a list, and then we'll actually use
3513            the return value.  */
3514         get_size_is_expr(type, var->name);
3515
3516         switch (tc)
3517         {
3518         case RPC_FC_SMFARRAY:
3519         case RPC_FC_LGFARRAY:
3520             array_type = "FixedArray";
3521             break;
3522         case RPC_FC_SMVARRAY:
3523         case RPC_FC_LGVARRAY:
3524             array_type = "VaryingArray";
3525             break;
3526         case RPC_FC_CARRAY:
3527             array_type = "ConformantArray";
3528             break;
3529         case RPC_FC_CVARRAY:
3530             array_type = "ConformantVaryingArray";
3531             break;
3532         case RPC_FC_BOGUS_ARRAY:
3533             array_type = "ComplexArray";
3534             break;
3535         }
3536
3537         if (pointer_type != RPC_FC_RP) array_type = "Pointer";
3538         print_phase_function(file, indent, array_type, local_var_prefix, phase, var, start_offset);
3539         if (phase == PHASE_FREE && pointer_type == RPC_FC_RP)
3540         {
3541             /* these are all unmarshalled by allocating memory */
3542             if (tc == RPC_FC_BOGUS_ARRAY ||
3543                 tc == RPC_FC_CVARRAY ||
3544                 ((tc == RPC_FC_SMVARRAY || tc == RPC_FC_LGVARRAY) && in_attr) ||
3545                 (tc == RPC_FC_CARRAY && !in_attr))
3546             {
3547                 print_file(file, indent, "if (%s%s)\n", local_var_prefix, var->name);
3548                 indent++;
3549                 print_file(file, indent, "__frame->_StubMsg.pfnFree(%s%s);\n", local_var_prefix, var->name);
3550             }
3551         }
3552         break;
3553     }
3554     case TGT_BASIC:
3555         print_phase_basetype(file, indent, local_var_prefix, phase, pass, var, var->name);
3556         break;
3557     case TGT_ENUM:
3558         print_phase_basetype(file, indent, local_var_prefix, phase, pass, var, var->name);
3559         break;
3560     case TGT_RANGE:
3561         print_phase_basetype(file, indent, local_var_prefix, phase, pass, var, var->name);
3562         /* Note: this goes beyond what MIDL does - it only supports arguments
3563          * with the [range] attribute in Oicf mode */
3564         if (phase == PHASE_UNMARSHAL)
3565         {
3566             const expr_t *range_min;
3567             const expr_t *range_max;
3568             expr_list_t *range_list = get_attrp(var->attrs, ATTR_RANGE);
3569             if (!range_list)
3570                 range_list = get_aliaschain_attrp(type, ATTR_RANGE);
3571             range_min = LIST_ENTRY(list_head(range_list), const expr_t, entry);
3572             range_max = LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
3573
3574             print_file(file, indent, "if ((%s%s < (", local_var_prefix, var->name);
3575             write_type_decl(file, var->type, NULL);
3576             fprintf(file, ")0x%lx) || (%s%s > (", range_min->cval, local_var_prefix, var->name);
3577             write_type_decl(file, var->type, NULL);
3578             fprintf(file, ")0x%lx))\n", range_max->cval);
3579             print_file(file, indent, "{\n");
3580             print_file(file, indent+1, "RpcRaiseException(RPC_S_INVALID_BOUND);\n");
3581             print_file(file, indent, "}\n");
3582         }
3583         break;
3584     case TGT_STRUCT:
3585         switch (get_struct_fc(type))
3586         {
3587         case RPC_FC_STRUCT:
3588             if (phase == PHASE_MARSHAL || phase == PHASE_UNMARSHAL)
3589                 print_phase_function(file, indent, "SimpleStruct", local_var_prefix, phase, var, start_offset);
3590             break;
3591         case RPC_FC_PSTRUCT:
3592             print_phase_function(file, indent, "SimpleStruct", local_var_prefix, phase, var, start_offset);
3593             break;
3594         case RPC_FC_CSTRUCT:
3595         case RPC_FC_CPSTRUCT:
3596             print_phase_function(file, indent, "ConformantStruct", local_var_prefix, phase, var, start_offset);
3597             break;
3598         case RPC_FC_CVSTRUCT:
3599             print_phase_function(file, indent, "ConformantVaryingStruct", local_var_prefix, phase, var, start_offset);
3600             break;
3601         case RPC_FC_BOGUS_STRUCT:
3602             print_phase_function(file, indent, "ComplexStruct", local_var_prefix, phase, var, start_offset);
3603             break;
3604         default:
3605             error("write_remoting_arguments: Unsupported type: %s (0x%02x)\n", var->name, get_struct_fc(type));
3606         }
3607         break;
3608     case TGT_UNION:
3609     {
3610         const char *union_type = NULL;
3611
3612         if (type_get_type(type) == TYPE_UNION)
3613             union_type = "NonEncapsulatedUnion";
3614         else if (type_get_type(type) == TYPE_ENCAPSULATED_UNION)
3615             union_type = "EncapsulatedUnion";
3616
3617         print_phase_function(file, indent, union_type, local_var_prefix,
3618                              phase, var, start_offset);
3619         break;
3620     }
3621     case TGT_POINTER:
3622     {
3623         const type_t *ref = type_pointer_get_ref(type);
3624         if (pointer_type == RPC_FC_RP) switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES))
3625         {
3626         case TGT_BASIC:
3627             print_phase_basetype(file, indent, local_var_prefix, phase, pass, var, var->name);
3628             break;
3629         case TGT_ENUM:
3630             /* base types have known sizes, so don't need a sizing pass
3631              * and don't have any memory to free and so don't need a
3632              * freeing pass */
3633             if (phase == PHASE_MARSHAL || phase == PHASE_UNMARSHAL)
3634                 print_phase_function(file, indent, "Pointer", local_var_prefix, phase, var, start_offset);
3635             break;
3636         case TGT_STRUCT:
3637         {
3638             const char *struct_type = NULL;
3639             switch (get_struct_fc(ref))
3640             {
3641             case RPC_FC_STRUCT:
3642                 /* simple structs have known sizes, so don't need a sizing
3643                  * pass and don't have any memory to free and so don't
3644                  * need a freeing pass */
3645                 if (phase == PHASE_MARSHAL || phase == PHASE_UNMARSHAL)
3646                     struct_type = "SimpleStruct";
3647                 else if (phase == PHASE_FREE && pass == PASS_RETURN)
3648                 {
3649                     print_file(file, indent, "if (%s%s)\n", local_var_prefix, var->name);
3650                     indent++;
3651                     print_file(file, indent, "__frame->_StubMsg.pfnFree(%s%s);\n", local_var_prefix, var->name);
3652                     indent--;
3653                 }
3654                 break;
3655             case RPC_FC_PSTRUCT:
3656                 struct_type = "SimpleStruct";
3657                 break;
3658             case RPC_FC_CSTRUCT:
3659             case RPC_FC_CPSTRUCT:
3660                 struct_type = "ConformantStruct";
3661                 break;
3662             case RPC_FC_CVSTRUCT:
3663                 struct_type = "ConformantVaryingStruct";
3664                 break;
3665             case RPC_FC_BOGUS_STRUCT:
3666                 struct_type = "ComplexStruct";
3667                 break;
3668             default:
3669                 error("write_remoting_arguments: Unsupported type: %s (0x%02x)\n", var->name, get_struct_fc(ref));
3670             }
3671
3672             if (struct_type)
3673             {
3674                 if (phase == PHASE_FREE)
3675                     struct_type = "Pointer";
3676                 else
3677                     start_offset = ref->typestring_offset;
3678                 print_phase_function(file, indent, struct_type, local_var_prefix, phase, var, start_offset);
3679             }
3680             break;
3681         }
3682         case TGT_UNION:
3683         {
3684             const char *union_type = NULL;
3685             if (phase == PHASE_FREE)
3686                 union_type = "Pointer";
3687             else
3688             {
3689                 if (type_get_type(ref) == TYPE_UNION)
3690                     union_type = "NonEncapsulatedUnion";
3691                 else if (type_get_type(ref) == TYPE_ENCAPSULATED_UNION)
3692                     union_type = "EncapsulatedUnion";
3693
3694                 start_offset = ref->typestring_offset;
3695             }
3696
3697             print_phase_function(file, indent, union_type, local_var_prefix,
3698                                  phase, var, start_offset);
3699             break;
3700         }
3701         case TGT_STRING:
3702         case TGT_POINTER:
3703         case TGT_ARRAY:
3704         case TGT_RANGE:
3705         case TGT_IFACE_POINTER:
3706         case TGT_USER_TYPE:
3707         case TGT_CTXT_HANDLE:
3708         case TGT_CTXT_HANDLE_POINTER:
3709             print_phase_function(file, indent, "Pointer", local_var_prefix, phase, var, start_offset);
3710             break;
3711         case TGT_INVALID:
3712             assert(0);
3713             break;
3714         }
3715         else
3716             print_phase_function(file, indent, "Pointer", local_var_prefix, phase, var, start_offset);
3717         break;
3718     }
3719     case TGT_IFACE_POINTER:
3720         print_phase_function(file, indent, "InterfacePointer", local_var_prefix, phase, var, start_offset);
3721         break;
3722     case TGT_INVALID:
3723         assert(0);
3724         break;
3725     }
3726     fprintf(file, "\n");
3727 }
3728
3729 void write_remoting_arguments(FILE *file, int indent, const var_t *func, const char *local_var_prefix,
3730                               enum pass pass, enum remoting_phase phase)
3731 {
3732     if (phase == PHASE_BUFFERSIZE && pass != PASS_RETURN)
3733     {
3734         unsigned int size = get_function_buffer_size( func, pass );
3735         print_file(file, indent, "__frame->_StubMsg.BufferLength = %u;\n", size);
3736     }
3737
3738     if (pass == PASS_RETURN)
3739     {
3740         var_t var;
3741         var = *func;
3742         var.type = type_function_get_rettype(func->type);
3743         var.name = xstrdup( "_RetVal" );
3744         write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, &var );
3745         free( var.name );
3746     }
3747     else
3748     {
3749         const var_t *var;
3750         if (!type_get_function_args(func->type))
3751             return;
3752         LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
3753             write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, var );
3754     }
3755 }
3756
3757
3758 unsigned int get_size_procformatstring_type(const char *name, const type_t *type, const attr_list_t *attrs)
3759 {
3760     return write_procformatstring_type(NULL, 0, name, type, attrs, FALSE);
3761 }
3762
3763
3764 unsigned int get_size_procformatstring_func(const var_t *func)
3765 {
3766     const var_t *var;
3767     unsigned int size = 0;
3768
3769     /* argument list size */
3770     if (type_get_function_args(func->type))
3771         LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
3772             size += get_size_procformatstring_type(var->name, var->type, var->attrs);
3773
3774     /* return value size */
3775     if (is_void(type_function_get_rettype(func->type)))
3776         size += 2; /* FC_END and FC_PAD */
3777     else
3778         size += get_size_procformatstring_type("return value", type_function_get_rettype(func->type), NULL);
3779
3780     return size;
3781 }
3782
3783 unsigned int get_size_procformatstring(const statement_list_t *stmts, type_pred_t pred)
3784 {
3785     const statement_t *stmt;
3786     unsigned int size = 1;
3787
3788     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
3789     {
3790         const type_t *iface;
3791         const statement_t *stmt_func;
3792
3793         if (stmt->type == STMT_LIBRARY)
3794         {
3795             size += get_size_procformatstring(stmt->u.lib->stmts, pred) - 1;
3796             continue;
3797         }
3798         else if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE)
3799             continue;
3800
3801         iface = stmt->u.type;
3802         if (!pred(iface))
3803             continue;
3804
3805         STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(iface) )
3806         {
3807             const var_t *func = stmt_func->u.var;
3808             if (!is_local(func->attrs))
3809                 size += get_size_procformatstring_func( func );
3810         }
3811     }
3812     return size;
3813 }
3814
3815 unsigned int get_size_typeformatstring(const statement_list_t *stmts, type_pred_t pred)
3816 {
3817     set_all_tfswrite(FALSE);
3818     return process_tfs(NULL, stmts, pred);
3819 }
3820
3821 void declare_stub_args( FILE *file, int indent, const var_t *func )
3822 {
3823     int in_attr, out_attr;
3824     int i = 0;
3825     const var_t *var;
3826
3827     /* declare return value '_RetVal' */
3828     if (!is_void(type_function_get_rettype(func->type)))
3829     {
3830         print_file(file, indent, "%s", "");
3831         write_type_decl_left(file, type_function_get_rettype(func->type));
3832         fprintf(file, " _RetVal;\n");
3833     }
3834
3835     if (!type_get_function_args(func->type))
3836         return;
3837
3838     LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
3839     {
3840         in_attr = is_attr(var->attrs, ATTR_IN);
3841         out_attr = is_attr(var->attrs, ATTR_OUT);
3842         if (!out_attr && !in_attr)
3843             in_attr = 1;
3844
3845         if (is_context_handle(var->type))
3846             print_file(file, indent, "NDR_SCONTEXT %s;\n", var->name);
3847         else
3848         {
3849             if (!in_attr && !is_conformant_array(var->type))
3850             {
3851                 type_t *type_to_print;
3852                 char name[16];
3853                 print_file(file, indent, "%s", "");
3854                 if (type_get_type(var->type) == TYPE_ARRAY &&
3855                     !type_array_is_decl_as_ptr(var->type))
3856                     type_to_print = var->type;
3857                 else
3858                     type_to_print = type_pointer_get_ref(var->type);
3859                 sprintf(name, "_W%u", i++);
3860                 write_type_decl(file, type_to_print, name);
3861                 fprintf(file, ";\n");
3862             }
3863
3864             print_file(file, indent, "%s", "");
3865             write_type_decl_left(file, var->type);
3866             fprintf(file, " ");
3867             if (type_get_type(var->type) == TYPE_ARRAY &&
3868                 !type_array_is_decl_as_ptr(var->type)) {
3869                 fprintf(file, "(*%s)", var->name);
3870             } else
3871                 fprintf(file, "%s", var->name);
3872             write_type_right(file, var->type, FALSE);
3873             fprintf(file, ";\n");
3874
3875             if (decl_indirect(var->type))
3876                 print_file(file, indent, "void *_p_%s;\n", var->name);
3877         }
3878     }
3879 }
3880
3881
3882 void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char *local_var_prefix )
3883 {
3884     int in_attr, out_attr;
3885     int i = 0, sep = 0;
3886     const var_t *var;
3887
3888     if (!type_get_function_args(func->type))
3889         return;
3890
3891     LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry )
3892     {
3893         in_attr = is_attr(var->attrs, ATTR_IN);
3894         out_attr = is_attr(var->attrs, ATTR_OUT);
3895         if (!out_attr && !in_attr)
3896             in_attr = 1;
3897
3898         if (!in_attr)
3899         {
3900             print_file(file, indent, "%s%s", local_var_prefix, var->name);
3901
3902             if (is_context_handle(var->type))
3903             {
3904                 fprintf(file, " = NdrContextHandleInitialize(\n");
3905                 print_file(file, indent + 1, "&__frame->_StubMsg,\n");
3906                 print_file(file, indent + 1, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]);\n",
3907                            var->type->typestring_offset);
3908             }
3909             else if (is_array(var->type) &&
3910                      type_array_has_conformance(var->type))
3911             {
3912                 unsigned int size, align = 0;
3913                 type_t *type = var->type;
3914
3915                 fprintf(file, " = NdrAllocate(&__frame->_StubMsg, ");
3916                 for ( ;
3917                      is_array(type) && type_array_has_conformance(type);
3918                      type = type_array_get_element(type))
3919                 {
3920                     write_expr(file, type_array_get_conformance(type), TRUE,
3921                                TRUE, NULL, NULL, local_var_prefix);
3922                     fprintf(file, " * ");
3923                 }
3924                 size = type_memsize(type, &align);
3925                 fprintf(file, "%u);\n", size);
3926             }
3927             else
3928             {
3929                 fprintf(file, " = &%s_W%u;\n", local_var_prefix, i);
3930                 switch (typegen_detect_type(type_pointer_get_ref(var->type), var->attrs, TDT_IGNORE_STRINGS))
3931                 {
3932                 case TGT_BASIC:
3933                 case TGT_ENUM:
3934                 case TGT_POINTER:
3935                 case TGT_RANGE:
3936                     print_file(file, indent, "%s_W%u = 0;\n", local_var_prefix, i);
3937                     break;
3938                 case TGT_STRUCT:
3939                 case TGT_UNION:
3940                 case TGT_USER_TYPE:
3941                 case TGT_IFACE_POINTER:
3942                 case TGT_ARRAY:
3943                 case TGT_CTXT_HANDLE:
3944                 case TGT_CTXT_HANDLE_POINTER:
3945                 case TGT_INVALID:
3946                 case TGT_STRING:
3947                     /* not initialised */
3948                     break;
3949                 }
3950                 i++;
3951             }
3952
3953             sep = 1;
3954         }
3955     }
3956     if (sep)
3957         fprintf(file, "\n");
3958 }
3959
3960
3961 int write_expr_eval_routines(FILE *file, const char *iface)
3962 {
3963     static const char *var_name = "pS";
3964     static const char *var_name_expr = "pS->";
3965     int result = 0;
3966     struct expr_eval_routine *eval;
3967     unsigned short callback_offset = 0;
3968
3969     LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
3970     {
3971         const char *name = eval->structure->name;
3972         result = 1;
3973
3974         print_file(file, 0, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
3975                    iface, name, callback_offset);
3976         print_file(file, 0, "{\n");
3977         print_file(file, 1, "%s", "");
3978         write_type_left(file, (type_t *)eval->structure, TRUE);
3979         fprintf(file, " *%s = (", var_name);
3980         write_type_left(file, (type_t *)eval->structure, TRUE);
3981         fprintf(file, " *)(pStubMsg->StackTop - %u);\n", eval->baseoff);
3982         print_file(file, 1, "pStubMsg->Offset = 0;\n"); /* FIXME */
3983         print_file(file, 1, "pStubMsg->MaxCount = (ULONG_PTR)");
3984         write_expr(file, eval->expr, 1, 1, var_name_expr, eval->structure, "");
3985         fprintf(file, ";\n");
3986         print_file(file, 0, "}\n\n");
3987         callback_offset++;
3988     }
3989     return result;
3990 }
3991
3992 void write_expr_eval_routine_list(FILE *file, const char *iface)
3993 {
3994     struct expr_eval_routine *eval;
3995     struct expr_eval_routine *cursor;
3996     unsigned short callback_offset = 0;
3997
3998     fprintf(file, "static const EXPR_EVAL ExprEvalRoutines[] =\n");
3999     fprintf(file, "{\n");
4000
4001     LIST_FOR_EACH_ENTRY_SAFE(eval, cursor, &expr_eval_routines, struct expr_eval_routine, entry)
4002     {
4003         const char *name = eval->structure->name;
4004         print_file(file, 1, "%s_%sExprEval_%04u,\n", iface, name, callback_offset);
4005         callback_offset++;
4006         list_remove(&eval->entry);
4007         free(eval);
4008     }
4009
4010     fprintf(file, "};\n\n");
4011 }
4012
4013 void write_user_quad_list(FILE *file)
4014 {
4015     user_type_t *ut;
4016
4017     if (list_empty(&user_type_list))
4018         return;
4019
4020     fprintf(file, "static const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[] =\n");
4021     fprintf(file, "{\n");
4022     LIST_FOR_EACH_ENTRY(ut, &user_type_list, user_type_t, entry)
4023     {
4024         const char *sep = &ut->entry == list_tail(&user_type_list) ? "" : ",";
4025         print_file(file, 1, "{\n");
4026         print_file(file, 2, "(USER_MARSHAL_SIZING_ROUTINE)%s_UserSize,\n", ut->name);
4027         print_file(file, 2, "(USER_MARSHAL_MARSHALLING_ROUTINE)%s_UserMarshal,\n", ut->name);
4028         print_file(file, 2, "(USER_MARSHAL_UNMARSHALLING_ROUTINE)%s_UserUnmarshal,\n", ut->name);
4029         print_file(file, 2, "(USER_MARSHAL_FREEING_ROUTINE)%s_UserFree\n", ut->name);
4030         print_file(file, 1, "}%s\n", sep);
4031     }
4032     fprintf(file, "};\n\n");
4033 }
4034
4035 void write_endpoints( FILE *f, const char *prefix, const str_list_t *list )
4036 {
4037     const struct str_list_entry_t *endpoint;
4038     const char *p;
4039
4040     /* this should be an array of RPC_PROTSEQ_ENDPOINT but we want const strings */
4041     print_file( f, 0, "static const unsigned char * const %s__RpcProtseqEndpoint[][2] =\n{\n", prefix );
4042     LIST_FOR_EACH_ENTRY( endpoint, list, const struct str_list_entry_t, entry )
4043     {
4044         print_file( f, 1, "{ (const unsigned char *)\"" );
4045         for (p = endpoint->str; *p && *p != ':'; p++)
4046         {
4047             if (*p == '"' || *p == '\\') fputc( '\\', f );
4048             fputc( *p, f );
4049         }
4050         if (!*p) goto error;
4051         if (p[1] != '[') goto error;
4052
4053         fprintf( f, "\", (const unsigned char *)\"" );
4054         for (p += 2; *p && *p != ']'; p++)
4055         {
4056             if (*p == '"' || *p == '\\') fputc( '\\', f );
4057             fputc( *p, f );
4058         }
4059         if (*p != ']') goto error;
4060         fprintf( f, "\" },\n" );
4061     }
4062     print_file( f, 0, "};\n\n" );
4063     return;
4064
4065 error:
4066     error("Invalid endpoint syntax '%s'\n", endpoint->str);
4067 }
4068
4069 void write_exceptions( FILE *file )
4070 {
4071     fprintf( file, "#ifndef USE_COMPILER_EXCEPTIONS\n");
4072     fprintf( file, "\n");
4073     fprintf( file, "#include \"wine/exception.h\"\n");
4074     fprintf( file, "#undef RpcTryExcept\n");
4075     fprintf( file, "#undef RpcExcept\n");
4076     fprintf( file, "#undef RpcEndExcept\n");
4077     fprintf( file, "#undef RpcTryFinally\n");
4078     fprintf( file, "#undef RpcFinally\n");
4079     fprintf( file, "#undef RpcEndFinally\n");
4080     fprintf( file, "#undef RpcExceptionCode\n");
4081     fprintf( file, "#undef RpcAbnormalTermination\n");
4082     fprintf( file, "\n");
4083     fprintf( file, "struct __exception_frame;\n");
4084     fprintf( file, "typedef int (*__filter_func)(struct __exception_frame *);\n");
4085     fprintf( file, "typedef void (*__finally_func)(struct __exception_frame *);\n");
4086     fprintf( file, "\n");
4087     fprintf( file, "#define __DECL_EXCEPTION_FRAME \\\n");
4088     fprintf( file, "    EXCEPTION_REGISTRATION_RECORD frame; \\\n");
4089     fprintf( file, "    __filter_func                 filter; \\\n");
4090     fprintf( file, "    __finally_func                finally; \\\n");
4091     fprintf( file, "    sigjmp_buf                    jmp; \\\n");
4092     fprintf( file, "    DWORD                         code; \\\n");
4093     fprintf( file, "    unsigned char                 abnormal_termination; \\\n");
4094     fprintf( file, "    unsigned char                 filter_level; \\\n");
4095     fprintf( file, "    unsigned char                 finally_level;\n");
4096     fprintf( file, "\n");
4097     fprintf( file, "struct __exception_frame\n{\n");
4098     fprintf( file, "    __DECL_EXCEPTION_FRAME\n");
4099     fprintf( file, "};\n");
4100     fprintf( file, "\n");
4101     fprintf( file, "static inline void __widl_unwind_target(void)\n" );
4102     fprintf( file, "{\n");
4103     fprintf( file, "    struct __exception_frame *exc_frame = (struct __exception_frame *)__wine_get_frame();\n" );
4104     fprintf( file, "    if (exc_frame->finally_level > exc_frame->filter_level)\n" );
4105     fprintf( file, "    {\n");
4106     fprintf( file, "        exc_frame->abnormal_termination = 1;\n");
4107     fprintf( file, "        exc_frame->finally( exc_frame );\n");
4108     fprintf( file, "        __wine_pop_frame( &exc_frame->frame );\n");
4109     fprintf( file, "    }\n");
4110     fprintf( file, "    exc_frame->filter_level = 0;\n");
4111     fprintf( file, "    siglongjmp( exc_frame->jmp, 1 );\n");
4112     fprintf( file, "}\n");
4113     fprintf( file, "\n");
4114     fprintf( file, "static DWORD __widl_exception_handler( EXCEPTION_RECORD *record,\n");
4115     fprintf( file, "                                       EXCEPTION_REGISTRATION_RECORD *frame,\n");
4116     fprintf( file, "                                       CONTEXT *context,\n");
4117     fprintf( file, "                                       EXCEPTION_REGISTRATION_RECORD **pdispatcher )\n");
4118     fprintf( file, "{\n");
4119     fprintf( file, "    struct __exception_frame *exc_frame = (struct __exception_frame *)frame;\n");
4120     fprintf( file, "\n");
4121     fprintf( file, "    if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND | EH_NESTED_CALL))\n");
4122     fprintf( file, "    {\n" );
4123     fprintf( file, "        if (exc_frame->finally_level && (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))\n");
4124     fprintf( file, "        {\n" );
4125     fprintf( file, "            exc_frame->abnormal_termination = 1;\n");
4126     fprintf( file, "            exc_frame->finally( exc_frame );\n");
4127     fprintf( file, "        }\n" );
4128     fprintf( file, "        return ExceptionContinueSearch;\n");
4129     fprintf( file, "    }\n" );
4130     fprintf( file, "    exc_frame->code = record->ExceptionCode;\n");
4131     fprintf( file, "    if (exc_frame->filter_level && exc_frame->filter( exc_frame ) == EXCEPTION_EXECUTE_HANDLER)\n" );
4132     fprintf( file, "        __wine_rtl_unwind( frame, record, __widl_unwind_target );\n");
4133     fprintf( file, "    return ExceptionContinueSearch;\n");
4134     fprintf( file, "}\n");
4135     fprintf( file, "\n");
4136     fprintf( file, "#define RpcTryExcept \\\n");
4137     fprintf( file, "    if (!sigsetjmp( __frame->jmp, 0 )) \\\n");
4138     fprintf( file, "    { \\\n");
4139     fprintf( file, "        if (!__frame->finally_level) \\\n" );
4140     fprintf( file, "            __wine_push_frame( &__frame->frame ); \\\n");
4141     fprintf( file, "        __frame->filter_level = __frame->finally_level + 1;\n" );
4142     fprintf( file, "\n");
4143     fprintf( file, "#define RpcExcept(expr) \\\n");
4144     fprintf( file, "        if (!__frame->finally_level) \\\n" );
4145     fprintf( file, "            __wine_pop_frame( &__frame->frame ); \\\n");
4146     fprintf( file, "        __frame->filter_level = 0; \\\n" );
4147     fprintf( file, "    } \\\n");
4148     fprintf( file, "    else \\\n");
4149     fprintf( file, "\n");
4150     fprintf( file, "#define RpcEndExcept\n");
4151     fprintf( file, "\n");
4152     fprintf( file, "#define RpcExceptionCode() (__frame->code)\n");
4153     fprintf( file, "\n");
4154     fprintf( file, "#define RpcTryFinally \\\n");
4155     fprintf( file, "    if (!__frame->filter_level) \\\n");
4156     fprintf( file, "        __wine_push_frame( &__frame->frame ); \\\n");
4157     fprintf( file, "    __frame->finally_level = __frame->filter_level + 1;\n");
4158     fprintf( file, "\n");
4159     fprintf( file, "#define RpcFinally \\\n");
4160     fprintf( file, "    if (!__frame->filter_level) \\\n");
4161     fprintf( file, "        __wine_pop_frame( &__frame->frame ); \\\n");
4162     fprintf( file, "    __frame->finally_level = 0;\n");
4163     fprintf( file, "\n");
4164     fprintf( file, "#define RpcEndFinally\n");
4165     fprintf( file, "\n");
4166     fprintf( file, "#define RpcAbnormalTermination() (__frame->abnormal_termination)\n");
4167     fprintf( file, "\n");
4168     fprintf( file, "#define RpcExceptionInit(filter_func,finally_func) \\\n");
4169     fprintf( file, "    do { \\\n");
4170     fprintf( file, "        __frame->frame.Handler = __widl_exception_handler; \\\n");
4171     fprintf( file, "        __frame->filter = (__filter_func)(filter_func); \\\n" );
4172     fprintf( file, "        __frame->finally = (__finally_func)(finally_func); \\\n");
4173     fprintf( file, "        __frame->abnormal_termination = 0; \\\n");
4174     fprintf( file, "        __frame->filter_level = 0; \\\n");
4175     fprintf( file, "        __frame->finally_level = 0; \\\n");
4176     fprintf( file, "    } while (0)\n");
4177     fprintf( file, "\n");
4178     fprintf( file, "#else /* USE_COMPILER_EXCEPTIONS */\n");
4179     fprintf( file, "\n");
4180     fprintf( file, "#define RpcExceptionInit(filter_func,finally_func) \\\n");
4181     fprintf( file, "    do { (void)(filter_func); } while(0)\n");
4182     fprintf( file, "\n");
4183     fprintf( file, "#define __DECL_EXCEPTION_FRAME \\\n");
4184     fprintf( file, "    DWORD code;\n");
4185     fprintf( file, "\n");
4186     fprintf( file, "#endif /* USE_COMPILER_EXCEPTIONS */\n");
4187 }