git.oblomov.eu Git - wine/blob - tools/widl/typegen.c

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