git.oblomov.eu Git - wine/blob - tools/widl/parser.y

   1 %{
   2 /*
   3  * IDL Compiler
   4  *
   5  * Copyright 2002 Ove Kaaven
   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
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <string.h>
  30 #ifdef HAVE_ALLOCA_H
  31 #include <alloca.h>
  32 #endif
  33
  34 #include "widl.h"
  35 #include "utils.h"
  36 #include "parser.h"
  37 #include "header.h"
  38 #include "typelib.h"
  39 #include "typegen.h"
  40
  41 #if defined(YYBYACC)
  42         /* Berkeley yacc (byacc) doesn't seem to know about these */
  43         /* Some *BSD supplied versions do define these though */
  44 # ifndef YYEMPTY
  45 #  define YYEMPTY       (-1)    /* Empty lookahead value of yychar */
  46 # endif
  47 # ifndef YYLEX
  48 #  define YYLEX         yylex()
  49 # endif
  50
  51 #elif defined(YYBISON)
  52         /* Bison was used for original development */
  53         /* #define YYEMPTY -2 */
  54         /* #define YYLEX   yylex() */
  55
  56 #else
  57         /* No yacc we know yet */
  58 # if !defined(YYEMPTY) || !defined(YYLEX)
  59 #  error Yacc version/type unknown. This version needs to be verified for settings of YYEMPTY and YYLEX.
  60 # elif defined(__GNUC__)        /* gcc defines the #warning directive */
  61 #  warning Yacc version/type unknown. It defines YYEMPTY and YYLEX, but is not tested
  62   /* #else we just take a chance that it works... */
  63 # endif
  64 #endif
  65
  66 #define YYERROR_VERBOSE
  67
  68 unsigned char pointer_default = RPC_FC_UP;
  69 static int is_object_interface = FALSE;
  70 /* are we inside a library block? */
  71 static int is_inside_library = FALSE;
  72
  73 typedef struct list typelist_t;
  74 struct typenode {
  75   type_t *type;
  76   struct list entry;
  77 };
  78
  79 typelist_t incomplete_types = LIST_INIT(incomplete_types);
  80
  81 static void add_incomplete(type_t *t);
  82 static void fix_incomplete(void);
  83
  84 static str_list_t *append_str(str_list_t *list, char *str);
  85 static attr_list_t *append_attr(attr_list_t *list, attr_t *attr);
  86 static attr_t *make_attr(enum attr_type type);
  87 static attr_t *make_attrv(enum attr_type type, unsigned long val);
  88 static attr_t *make_attrp(enum attr_type type, void *val);
  89 static expr_t *make_expr(enum expr_type type);
  90 static expr_t *make_exprl(enum expr_type type, long val);
  91 static expr_t *make_exprd(enum expr_type type, double val);
  92 static expr_t *make_exprs(enum expr_type type, char *val);
  93 static expr_t *make_exprt(enum expr_type type, type_t *tref, expr_t *expr);
  94 static expr_t *make_expr1(enum expr_type type, expr_t *expr);
  95 static expr_t *make_expr2(enum expr_type type, expr_t *exp1, expr_t *exp2);
  96 static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3);
  97 static type_t *make_type(unsigned char type, type_t *ref);
  98 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr);
  99 static array_dims_t *append_array(array_dims_t *list, expr_t *expr);
 100 static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr, int top);
 101 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface);
 102 static ifref_t *make_ifref(type_t *iface);
 103 static var_list_t *append_var(var_list_t *list, var_t *var);
 104 static var_t *make_var(char *name);
 105 static pident_list_t *append_pident(pident_list_t *list, pident_t *p);
 106 static pident_t *make_pident(var_t *var);
 107 static func_list_t *append_func(func_list_t *list, func_t *func);
 108 static func_t *make_func(var_t *def, var_list_t *args);
 109 static type_t *make_class(char *name);
 110 static type_t *make_safearray(type_t *type);
 111 static type_t *make_builtin(char *name);
 112 static type_t *make_int(int sign);
 113
 114 static type_t *reg_type(type_t *type, const char *name, int t);
 115 static type_t *reg_typedefs(type_t *type, var_list_t *names, attr_list_t *attrs);
 116 static type_t *find_type(const char *name, int t);
 117 static type_t *find_type2(char *name, int t);
 118 static type_t *get_type(unsigned char type, char *name, int t);
 119 static type_t *get_typev(unsigned char type, var_t *name, int t);
 120 static int get_struct_type(var_list_t *fields);
 121
 122 static var_t *reg_const(var_t *var);
 123 static var_t *find_const(char *name, int f);
 124
 125 static void write_libid(const char *name, const attr_list_t *attr);
 126 static void write_clsid(type_t *cls);
 127 static void write_diid(type_t *iface);
 128 static void write_iid(type_t *iface);
 129
 130 static int compute_method_indexes(type_t *iface);
 131 static char *gen_name(void);
 132 static void process_typedefs(var_list_t *names);
 133 static void check_arg(var_t *arg);
 134 static void check_functions(const type_t *iface);
 135 static void check_all_user_types(ifref_list_t *ifaces);
 136 static const attr_list_t *check_iface_attrs(const char *name, const attr_list_t *attrs);
 137 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs);
 138 static attr_list_t *check_typedef_attrs(attr_list_t *attrs);
 139 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs);
 140 static const attr_list_t *check_library_attrs(const char *name, const attr_list_t *attrs);
 141 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs);
 142 static const attr_list_t *check_module_attrs(const char *name, const attr_list_t *attrs);
 143 static const attr_list_t *check_coclass_attrs(const char *name, const attr_list_t *attrs);
 144 const char *get_attr_display_name(enum attr_type type);
 145 static void add_explicit_handle_if_necessary(func_t *func);
 146
 147 #define tsENUM   1
 148 #define tsSTRUCT 2
 149 #define tsUNION  3
 150
 151 %}
 152 %union {
 153         attr_t *attr;
 154         attr_list_t *attr_list;
 155         str_list_t *str_list;
 156         expr_t *expr;
 157         expr_list_t *expr_list;
 158         array_dims_t *array_dims;
 159         type_t *type;
 160         var_t *var;
 161         var_list_t *var_list;
 162         pident_t *pident;
 163         pident_list_t *pident_list;
 164         func_t *func;
 165         func_list_t *func_list;
 166         ifref_t *ifref;
 167         ifref_list_t *ifref_list;
 168         char *str;
 169         UUID *uuid;
 170         unsigned int num;
 171         double dbl;
 172         interface_info_t ifinfo;
 173 }
 174
 175 %token <str> aIDENTIFIER
 176 %token <str> aKNOWNTYPE
 177 %token <num> aNUM aHEXNUM
 178 %token <dbl> aDOUBLE
 179 %token <str> aSTRING
 180 %token <uuid> aUUID
 181 %token aEOF
 182 %token SHL SHR
 183 %token MEMBERPTR
 184 %token tAGGREGATABLE tALLOCATE tAPPOBJECT tASYNC tASYNCUUID
 185 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
 186 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
 187 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
 188 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
 189 %token tDEFAULT
 190 %token tDEFAULTCOLLELEM
 191 %token tDEFAULTVALUE
 192 %token tDEFAULTVTABLE
 193 %token tDISPLAYBIND
 194 %token tDISPINTERFACE
 195 %token tDLLNAME tDOUBLE tDUAL
 196 %token tENDPOINT
 197 %token tENTRY tENUM tERRORSTATUST
 198 %token tEXPLICITHANDLE tEXTERN
 199 %token tFALSE
 200 %token tFASTCALL
 201 %token tFLOAT
 202 %token tHANDLE
 203 %token tHANDLET
 204 %token tHELPCONTEXT tHELPFILE
 205 %token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
 206 %token tHIDDEN
 207 %token tHYPER tID tIDEMPOTENT
 208 %token tIIDIS
 209 %token tIMMEDIATEBIND
 210 %token tIMPLICITHANDLE
 211 %token tIMPORT tIMPORTLIB
 212 %token tIN tINLINE
 213 %token tINPUTSYNC
 214 %token tINT tINT64
 215 %token tINTERFACE
 216 %token tLCID
 217 %token tLENGTHIS tLIBRARY
 218 %token tLOCAL
 219 %token tLONG
 220 %token tMETHODS
 221 %token tMODULE
 222 %token tNONBROWSABLE
 223 %token tNONCREATABLE
 224 %token tNONEXTENSIBLE
 225 %token tOBJECT tODL tOLEAUTOMATION
 226 %token tOPTIONAL
 227 %token tOUT
 228 %token tPASCAL
 229 %token tPOINTERDEFAULT
 230 %token tPROPERTIES
 231 %token tPROPGET tPROPPUT tPROPPUTREF
 232 %token tPTR
 233 %token tPUBLIC
 234 %token tRANGE
 235 %token tREADONLY tREF
 236 %token tREQUESTEDIT
 237 %token tRESTRICTED
 238 %token tRETVAL
 239 %token tSAFEARRAY
 240 %token tSHORT
 241 %token tSIGNED
 242 %token tSINGLE
 243 %token tSIZEIS tSIZEOF
 244 %token tSMALL
 245 %token tSOURCE
 246 %token tSTDCALL
 247 %token tSTRICTCONTEXTHANDLE
 248 %token tSTRING tSTRUCT
 249 %token tSWITCH tSWITCHIS tSWITCHTYPE
 250 %token tTRANSMITAS
 251 %token tTRUE
 252 %token tTYPEDEF
 253 %token tUNION
 254 %token tUNIQUE
 255 %token tUNSIGNED
 256 %token tUUID
 257 %token tV1ENUM
 258 %token tVARARG
 259 %token tVERSION
 260 %token tVOID
 261 %token tWCHAR tWIREMARSHAL
 262
 263 %type <attr> attribute
 264 %type <attr_list> m_attributes attributes attrib_list
 265 %type <str_list> str_list
 266 %type <expr> m_expr expr expr_const
 267 %type <expr_list> m_exprs /* exprs expr_list */ expr_list_const
 268 %type <array_dims> array array_list
 269 %type <ifinfo> interfacehdr
 270 %type <type> inherit interface interfacedef interfacedec
 271 %type <type> dispinterface dispinterfacehdr dispinterfacedef
 272 %type <type> module modulehdr moduledef
 273 %type <type> base_type int_std
 274 %type <type> enumdef structdef uniondef
 275 %type <type> type
 276 %type <ifref> coclass_int
 277 %type <ifref_list> gbl_statements coclass_ints
 278 %type <var> arg field s_field case enum constdef externdef
 279 %type <var_list> m_args no_args args fields cases enums enum_list dispint_props
 280 %type <var> m_ident t_ident ident
 281 %type <pident> pident func_ident direct_ident
 282 %type <pident_list> pident_list
 283 %type <func> funcdef
 284 %type <func_list> int_statements dispint_meths
 285 %type <type> coclass coclasshdr coclassdef
 286 %type <num> pointer_type version
 287 %type <str> libraryhdr callconv
 288 %type <uuid> uuid_string
 289 %type <num> import_start
 290
 291 %left ','
 292 %right '?' ':'
 293 %left '|'
 294 %left '&'
 295 %left SHL SHR
 296 %left '-' '+'
 297 %left '*' '/' '%'
 298 %right '~' CAST PPTR NEG ADDRESSOF tSIZEOF
 299 %left '.' MEMBERPTR '[' ']'
 300
 301 %%
 302
 303 input:   gbl_statements                         { fix_incomplete();
 304                                                   check_all_user_types($1);
 305                                                   write_proxies($1);
 306                                                   write_client($1);
 307                                                   write_server($1);
 308                                                   write_dlldata($1);
 309                                                 }
 310         ;
 311
 312 gbl_statements:                                 { $$ = NULL; }
 313         | gbl_statements interfacedec           { $$ = $1; }
 314         | gbl_statements interfacedef           { $$ = append_ifref( $1, make_ifref($2) ); }
 315         | gbl_statements coclass ';'            { $$ = $1;
 316                                                   reg_type($2, $2->name, 0);
 317                                                   if (!parse_only && do_header) write_coclass_forward($2);
 318                                                 }
 319         | gbl_statements coclassdef             { $$ = $1;
 320                                                   add_typelib_entry($2);
 321                                                   reg_type($2, $2->name, 0);
 322                                                   if (!parse_only && do_header) write_coclass_forward($2);
 323                                                 }
 324         | gbl_statements moduledef              { $$ = $1; add_typelib_entry($2); }
 325         | gbl_statements librarydef             { $$ = $1; }
 326         | gbl_statements statement              { $$ = $1; }
 327         ;
 328
 329 imp_statements:                                 {}
 330         | imp_statements interfacedec           { if (!parse_only) add_typelib_entry($2); }
 331         | imp_statements interfacedef           { if (!parse_only) add_typelib_entry($2); }
 332         | imp_statements coclass ';'            { reg_type($2, $2->name, 0); if (!parse_only && do_header) write_coclass_forward($2); }
 333         | imp_statements coclassdef             { if (!parse_only) add_typelib_entry($2);
 334                                                   reg_type($2, $2->name, 0);
 335                                                   if (!parse_only && do_header) write_coclass_forward($2);
 336                                                 }
 337         | imp_statements moduledef              { if (!parse_only) add_typelib_entry($2); }
 338         | imp_statements statement              {}
 339         | imp_statements importlib              {}
 340         | imp_statements librarydef             {}
 341         ;
 342
 343 int_statements:                                 { $$ = NULL; }
 344         | int_statements funcdef ';'            { $$ = append_func( $1, $2 ); }
 345         | int_statements statement              { $$ = $1; }
 346         ;
 347
 348 semicolon_opt:
 349         | ';'
 350         ;
 351
 352 statement: constdef ';'                         { if (!parse_only && do_header) { write_constdef($1); } }
 353         | cppquote                              {}
 354         | enumdef ';'                           { if (!parse_only && do_header) {
 355                                                     write_type_def_or_decl(header, $1, FALSE, NULL);
 356                                                     fprintf(header, ";\n\n");
 357                                                   }
 358                                                 }
 359         | externdef ';'                         { if (!parse_only && do_header) { write_externdef($1); } }
 360         | import                                {}
 361         | structdef ';'                         { if (!parse_only && do_header) {
 362                                                     write_type_def_or_decl(header, $1, FALSE, NULL);
 363                                                     fprintf(header, ";\n\n");
 364                                                   }
 365                                                 }
 366         | typedef ';'                           {}
 367         | uniondef ';'                          { if (!parse_only && do_header) {
 368                                                     write_type_def_or_decl(header, $1, FALSE, NULL);
 369                                                     fprintf(header, ";\n\n");
 370                                                   }
 371                                                 }
 372         ;
 373
 374 cppquote: tCPPQUOTE '(' aSTRING ')'             { if (!parse_only && do_header) fprintf(header, "%s\n", $3); }
 375         ;
 376 import_start: tIMPORT aSTRING ';'               { assert(yychar == YYEMPTY);
 377                                                   $$ = do_import($2);
 378                                                   if (!$$) yychar = aEOF;
 379                                                 }
 380         ;
 381
 382 import: import_start imp_statements aEOF
 383                                                 { if ($1) pop_import(); }
 384         ;
 385
 386 importlib: tIMPORTLIB '(' aSTRING ')'
 387            semicolon_opt                        { if(!parse_only) add_importlib($3); }
 388         ;
 389
 390 libraryhdr: tLIBRARY aIDENTIFIER                { $$ = $2; }
 391         ;
 392 library_start: attributes libraryhdr '{'        { check_library_attrs($2, $1);
 393                                                   if (!parse_only) start_typelib($2, $1);
 394                                                   if (!parse_only && do_header) write_library($2, $1);
 395                                                   if (!parse_only && do_idfile) write_libid($2, $1);
 396                                                   is_inside_library = TRUE;
 397                                                 }
 398         ;
 399 librarydef: library_start imp_statements '}'
 400             semicolon_opt                       { if (!parse_only) end_typelib(); is_inside_library = FALSE; }
 401         ;
 402
 403 m_args:                                         { $$ = NULL; }
 404         | args
 405         ;
 406
 407 no_args:  tVOID                                 { $$ = NULL; }
 408         ;
 409
 410 args:     arg                                   { check_arg($1); $$ = append_var( NULL, $1 ); }
 411         | args ',' arg                          { check_arg($3); $$ = append_var( $1, $3); }
 412         | no_args
 413         ;
 414
 415 /* split into two rules to get bison to resolve a tVOID conflict */
 416 arg:      attributes type pident array          { $$ = $3->var;
 417                                                   $$->attrs = $1;
 418                                                   set_type($$, $2, $3, $4, TRUE);
 419                                                   free($3);
 420                                                 }
 421         | type pident array                     { $$ = $2->var;
 422                                                   set_type($$, $1, $2, $3, TRUE);
 423                                                   free($2);
 424                                                 }
 425         ;
 426
 427 array:                                          { $$ = NULL; }
 428         | '[' array_list ']'                    { $$ = $2; }
 429         | '[' '*' ']'                           { $$ = append_array( NULL, make_expr(EXPR_VOID) ); }
 430         ;
 431
 432 array_list: m_expr /* size of first dimension is optional */ { $$ = append_array( NULL, $1 ); }
 433         | array_list ',' expr                   { $$ = append_array( $1, $3 ); }
 434         | array_list ']' '[' expr               { $$ = append_array( $1, $4 ); }
 435         ;
 436
 437 m_attributes:                                   { $$ = NULL; }
 438         | attributes
 439         ;
 440
 441 attributes:
 442           '[' attrib_list ']'                   { $$ = $2;
 443                                                   if (!$$)
 444                                                     error_loc("empty attribute lists unsupported\n");
 445                                                 }
 446         ;
 447
 448 attrib_list: attribute                          { $$ = append_attr( NULL, $1 ); }
 449         | attrib_list ',' attribute             { $$ = append_attr( $1, $3 ); }
 450         | attrib_list ']' '[' attribute         { $$ = append_attr( $1, $4 ); }
 451         ;
 452
 453 str_list: aSTRING                               { $$ = append_str( NULL, $1 ); }
 454         | str_list ',' aSTRING                  { $$ = append_str( $1, $3 ); }
 455         ;
 456
 457 attribute:                                      { $$ = NULL; }
 458         | tAGGREGATABLE                         { $$ = make_attr(ATTR_AGGREGATABLE); }
 459         | tAPPOBJECT                            { $$ = make_attr(ATTR_APPOBJECT); }
 460         | tASYNC                                { $$ = make_attr(ATTR_ASYNC); }
 461         | tAUTOHANDLE                           { $$ = make_attr(ATTR_AUTO_HANDLE); }
 462         | tBINDABLE                             { $$ = make_attr(ATTR_BINDABLE); }
 463         | tBROADCAST                            { $$ = make_attr(ATTR_BROADCAST); }
 464         | tCALLAS '(' ident ')'                 { $$ = make_attrp(ATTR_CALLAS, $3); }
 465         | tCASE '(' expr_list_const ')'         { $$ = make_attrp(ATTR_CASE, $3); }
 466         | tCONTEXTHANDLE                        { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); }
 467         | tCONTEXTHANDLENOSERIALIZE             { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
 468         | tCONTEXTHANDLESERIALIZE               { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
 469         | tCONTROL                              { $$ = make_attr(ATTR_CONTROL); }
 470         | tDEFAULT                              { $$ = make_attr(ATTR_DEFAULT); }
 471         | tDEFAULTCOLLELEM                      { $$ = make_attr(ATTR_DEFAULTCOLLELEM); }
 472         | tDEFAULTVALUE '(' expr_const ')'      { $$ = make_attrp(ATTR_DEFAULTVALUE_EXPR, $3); }
 473         | tDEFAULTVALUE '(' aSTRING ')'         { $$ = make_attrp(ATTR_DEFAULTVALUE_STRING, $3); }
 474         | tDEFAULTVTABLE                        { $$ = make_attr(ATTR_DEFAULTVTABLE); }
 475         | tDISPLAYBIND                          { $$ = make_attr(ATTR_DISPLAYBIND); }
 476         | tDLLNAME '(' aSTRING ')'              { $$ = make_attrp(ATTR_DLLNAME, $3); }
 477         | tDUAL                                 { $$ = make_attr(ATTR_DUAL); }
 478         | tENDPOINT '(' str_list ')'            { $$ = make_attrp(ATTR_ENDPOINT, $3); }
 479         | tENTRY '(' aSTRING ')'                { $$ = make_attrp(ATTR_ENTRY_STRING, $3); }
 480         | tENTRY '(' expr_const ')'             { $$ = make_attrp(ATTR_ENTRY_ORDINAL, $3); }
 481         | tEXPLICITHANDLE                       { $$ = make_attr(ATTR_EXPLICIT_HANDLE); }
 482         | tHANDLE                               { $$ = make_attr(ATTR_HANDLE); }
 483         | tHELPCONTEXT '(' expr_const ')'       { $$ = make_attrp(ATTR_HELPCONTEXT, $3); }
 484         | tHELPFILE '(' aSTRING ')'             { $$ = make_attrp(ATTR_HELPFILE, $3); }
 485         | tHELPSTRING '(' aSTRING ')'           { $$ = make_attrp(ATTR_HELPSTRING, $3); }
 486         | tHELPSTRINGCONTEXT '(' expr_const ')' { $$ = make_attrp(ATTR_HELPSTRINGCONTEXT, $3); }
 487         | tHELPSTRINGDLL '(' aSTRING ')'        { $$ = make_attrp(ATTR_HELPSTRINGDLL, $3); }
 488         | tHIDDEN                               { $$ = make_attr(ATTR_HIDDEN); }
 489         | tID '(' expr_const ')'                { $$ = make_attrp(ATTR_ID, $3); }
 490         | tIDEMPOTENT                           { $$ = make_attr(ATTR_IDEMPOTENT); }
 491         | tIIDIS '(' expr ')'                   { $$ = make_attrp(ATTR_IIDIS, $3); }
 492         | tIMMEDIATEBIND                        { $$ = make_attr(ATTR_IMMEDIATEBIND); }
 493         | tIMPLICITHANDLE '(' tHANDLET aIDENTIFIER ')'  { $$ = make_attrp(ATTR_IMPLICIT_HANDLE, $4); }
 494         | tIN                                   { $$ = make_attr(ATTR_IN); }
 495         | tINPUTSYNC                            { $$ = make_attr(ATTR_INPUTSYNC); }
 496         | tLENGTHIS '(' m_exprs ')'             { $$ = make_attrp(ATTR_LENGTHIS, $3); }
 497         | tLOCAL                                { $$ = make_attr(ATTR_LOCAL); }
 498         | tNONBROWSABLE                         { $$ = make_attr(ATTR_NONBROWSABLE); }
 499         | tNONCREATABLE                         { $$ = make_attr(ATTR_NONCREATABLE); }
 500         | tNONEXTENSIBLE                        { $$ = make_attr(ATTR_NONEXTENSIBLE); }
 501         | tOBJECT                               { $$ = make_attr(ATTR_OBJECT); }
 502         | tODL                                  { $$ = make_attr(ATTR_ODL); }
 503         | tOLEAUTOMATION                        { $$ = make_attr(ATTR_OLEAUTOMATION); }
 504         | tOPTIONAL                             { $$ = make_attr(ATTR_OPTIONAL); }
 505         | tOUT                                  { $$ = make_attr(ATTR_OUT); }
 506         | tPOINTERDEFAULT '(' pointer_type ')'  { $$ = make_attrv(ATTR_POINTERDEFAULT, $3); }
 507         | tPROPGET                              { $$ = make_attr(ATTR_PROPGET); }
 508         | tPROPPUT                              { $$ = make_attr(ATTR_PROPPUT); }
 509         | tPROPPUTREF                           { $$ = make_attr(ATTR_PROPPUTREF); }
 510         | tPUBLIC                               { $$ = make_attr(ATTR_PUBLIC); }
 511         | tRANGE '(' expr_const ',' expr_const ')' { expr_list_t *list = append_expr( NULL, $3 );
 512                                                      list = append_expr( list, $5 );
 513                                                      $$ = make_attrp(ATTR_RANGE, list); }
 514         | tREADONLY                             { $$ = make_attr(ATTR_READONLY); }
 515         | tREQUESTEDIT                          { $$ = make_attr(ATTR_REQUESTEDIT); }
 516         | tRESTRICTED                           { $$ = make_attr(ATTR_RESTRICTED); }
 517         | tRETVAL                               { $$ = make_attr(ATTR_RETVAL); }
 518         | tSIZEIS '(' m_exprs ')'               { $$ = make_attrp(ATTR_SIZEIS, $3); }
 519         | tSOURCE                               { $$ = make_attr(ATTR_SOURCE); }
 520         | tSTRICTCONTEXTHANDLE                  { $$ = make_attr(ATTR_STRICTCONTEXTHANDLE); }
 521         | tSTRING                               { $$ = make_attr(ATTR_STRING); }
 522         | tSWITCHIS '(' expr ')'                { $$ = make_attrp(ATTR_SWITCHIS, $3); }
 523         | tSWITCHTYPE '(' type ')'              { $$ = make_attrp(ATTR_SWITCHTYPE, $3); }
 524         | tTRANSMITAS '(' type ')'              { $$ = make_attrp(ATTR_TRANSMITAS, $3); }
 525         | tUUID '(' uuid_string ')'             { $$ = make_attrp(ATTR_UUID, $3); }
 526         | tV1ENUM                               { $$ = make_attr(ATTR_V1ENUM); }
 527         | tVARARG                               { $$ = make_attr(ATTR_VARARG); }
 528         | tVERSION '(' version ')'              { $$ = make_attrv(ATTR_VERSION, $3); }
 529         | tWIREMARSHAL '(' type ')'             { $$ = make_attrp(ATTR_WIREMARSHAL, $3); }
 530         | pointer_type                          { $$ = make_attrv(ATTR_POINTERTYPE, $1); }
 531         ;
 532
 533 uuid_string:
 534           aUUID
 535         | aSTRING                               { if (!is_valid_uuid($1))
 536                                                     error_loc("invalid UUID: %s\n", $1);
 537                                                   $$ = parse_uuid($1); }
 538         ;
 539
 540 callconv: tCDECL                                { $$ = $<str>1; }
 541         | tFASTCALL                             { $$ = $<str>1; }
 542         | tPASCAL                               { $$ = $<str>1; }
 543         | tSTDCALL                              { $$ = $<str>1; }
 544         ;
 545
 546 cases:                                          { $$ = NULL; }
 547         | cases case                            { $$ = append_var( $1, $2 ); }
 548         ;
 549
 550 case:     tCASE expr ':' field                  { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, $2 ));
 551                                                   $$ = $4; if (!$$) $$ = make_var(NULL);
 552                                                   $$->attrs = append_attr( $$->attrs, a );
 553                                                 }
 554         | tDEFAULT ':' field                    { attr_t *a = make_attr(ATTR_DEFAULT);
 555                                                   $$ = $3; if (!$$) $$ = make_var(NULL);
 556                                                   $$->attrs = append_attr( $$->attrs, a );
 557                                                 }
 558         ;
 559
 560 constdef: tCONST type ident '=' expr_const      { $$ = reg_const($3);
 561                                                   set_type($$, $2, NULL, NULL, FALSE);
 562                                                   $$->eval = $5;
 563                                                 }
 564         ;
 565
 566 enums:                                          { $$ = NULL; }
 567         | enum_list ','                         { $$ = $1; }
 568         | enum_list
 569         ;
 570
 571 enum_list: enum                                 { if (!$1->eval)
 572                                                     $1->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
 573                                                   $$ = append_var( NULL, $1 );
 574                                                 }
 575         | enum_list ',' enum                    { if (!$3->eval)
 576                                                   {
 577                                                     var_t *last = LIST_ENTRY( list_tail($$), var_t, entry );
 578                                                     $3->eval = make_exprl(EXPR_NUM, last->eval->cval + 1);
 579                                                   }
 580                                                   $$ = append_var( $1, $3 );
 581                                                 }
 582         ;
 583
 584 enum:     ident '=' expr_const                  { $$ = reg_const($1);
 585                                                   $$->eval = $3;
 586                                                   $$->type = make_int(0);
 587                                                 }
 588         | ident                                 { $$ = reg_const($1);
 589                                                   $$->type = make_int(0);
 590                                                 }
 591         ;
 592
 593 enumdef: tENUM t_ident '{' enums '}'            { $$ = get_typev(RPC_FC_ENUM16, $2, tsENUM);
 594                                                   $$->kind = TKIND_ENUM;
 595                                                   $$->fields_or_args = $4;
 596                                                   $$->defined = TRUE;
 597                                                   if(in_typelib)
 598                                                       add_typelib_entry($$);
 599                                                 }
 600         ;
 601
 602 m_exprs:  m_expr                                { $$ = append_expr( NULL, $1 ); }
 603         | m_exprs ',' m_expr                    { $$ = append_expr( $1, $3 ); }
 604         ;
 605
 606 /*
 607 exprs:                                          { $$ = make_expr(EXPR_VOID); }
 608         | expr_list
 609         ;
 610
 611 expr_list: expr
 612         | expr_list ',' expr                    { LINK($3, $1); $$ = $3; }
 613         ;
 614 */
 615
 616 m_expr:                                         { $$ = make_expr(EXPR_VOID); }
 617         | expr
 618         ;
 619
 620 expr:     aNUM                                  { $$ = make_exprl(EXPR_NUM, $1); }
 621         | aHEXNUM                               { $$ = make_exprl(EXPR_HEXNUM, $1); }
 622         | aDOUBLE                               { $$ = make_exprd(EXPR_DOUBLE, $1); }
 623         | tFALSE                                { $$ = make_exprl(EXPR_TRUEFALSE, 0); }
 624         | tTRUE                                 { $$ = make_exprl(EXPR_TRUEFALSE, 1); }
 625         | aIDENTIFIER                           { $$ = make_exprs(EXPR_IDENTIFIER, $1); }
 626         | expr '?' expr ':' expr                { $$ = make_expr3(EXPR_COND, $1, $3, $5); }
 627         | expr '|' expr                         { $$ = make_expr2(EXPR_OR , $1, $3); }
 628         | expr '&' expr                         { $$ = make_expr2(EXPR_AND, $1, $3); }
 629         | expr '+' expr                         { $$ = make_expr2(EXPR_ADD, $1, $3); }
 630         | expr '-' expr                         { $$ = make_expr2(EXPR_SUB, $1, $3); }
 631         | expr '%' expr                         { $$ = make_expr2(EXPR_MOD, $1, $3); }
 632         | expr '*' expr                         { $$ = make_expr2(EXPR_MUL, $1, $3); }
 633         | expr '/' expr                         { $$ = make_expr2(EXPR_DIV, $1, $3); }
 634         | expr SHL expr                         { $$ = make_expr2(EXPR_SHL, $1, $3); }
 635         | expr SHR expr                         { $$ = make_expr2(EXPR_SHR, $1, $3); }
 636         | '~' expr                              { $$ = make_expr1(EXPR_NOT, $2); }
 637         | '-' expr %prec NEG                    { $$ = make_expr1(EXPR_NEG, $2); }
 638         | '&' expr %prec ADDRESSOF              { $$ = make_expr1(EXPR_ADDRESSOF, $2); }
 639         | '*' expr %prec PPTR                   { $$ = make_expr1(EXPR_PPTR, $2); }
 640         | expr MEMBERPTR expr                   { $$ = make_expr2(EXPR_MEMBERPTR, $1, $3); }
 641         | expr '.' expr                         { $$ = make_expr2(EXPR_MEMBER, $1, $3); }
 642         | '(' type ')' expr %prec CAST          { $$ = make_exprt(EXPR_CAST, $2, $4); }
 643         | tSIZEOF '(' type ')'                  { $$ = make_exprt(EXPR_SIZEOF, $3, NULL); }
 644         | expr '[' expr ']'                     { $$ = make_expr2(EXPR_ARRAY, $1, $3); }
 645         | '(' expr ')'                          { $$ = $2; }
 646         ;
 647
 648 expr_list_const: expr_const                     { $$ = append_expr( NULL, $1 ); }
 649         | expr_list_const ',' expr_const        { $$ = append_expr( $1, $3 ); }
 650         ;
 651
 652 expr_const: expr                                { $$ = $1;
 653                                                   if (!$$->is_const)
 654                                                       error_loc("expression is not constant\n");
 655                                                 }
 656         ;
 657
 658 externdef: tEXTERN tCONST type ident            { $$ = $4;
 659                                                   set_type($$, $3, NULL, NULL, FALSE);
 660                                                 }
 661         ;
 662
 663 fields:                                         { $$ = NULL; }
 664         | fields field                          { $$ = append_var( $1, $2 ); }
 665         ;
 666
 667 field:    s_field ';'                           { $$ = $1; }
 668         | m_attributes uniondef ';'             { $$ = make_var(NULL); $$->type = $2; $$->attrs = $1; }
 669         | attributes ';'                        { $$ = make_var(NULL); $$->attrs = $1; }
 670         | ';'                                   { $$ = NULL; }
 671         ;
 672
 673 s_field:  m_attributes type pident array        { $$ = $3->var;
 674                                                   $$->attrs = check_field_attrs($$->name, $1);
 675                                                   set_type($$, $2, $3, $4, FALSE);
 676                                                   free($3);
 677                                                 }
 678         ;
 679
 680 funcdef:
 681           m_attributes type pident              { var_t *v = $3->var;
 682                                                   var_list_t *args = $3->args;
 683                                                   v->attrs = check_function_attrs(v->name, $1);
 684                                                   set_type(v, $2, $3, NULL, FALSE);
 685                                                   free($3);
 686                                                   $$ = make_func(v, args);
 687                                                 }
 688         ;
 689
 690 m_ident:                                        { $$ = NULL; }
 691         | ident
 692         ;
 693
 694 t_ident:                                        { $$ = NULL; }
 695         | aIDENTIFIER                           { $$ = make_var($1); }
 696         | aKNOWNTYPE                            { $$ = make_var($1); }
 697         ;
 698
 699 ident:    aIDENTIFIER                           { $$ = make_var($1); }
 700 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
 701         | aKNOWNTYPE                            { $$ = make_var($<str>1); }
 702         ;
 703
 704 base_type: tBYTE                                { $$ = make_builtin($<str>1); }
 705         | tWCHAR                                { $$ = make_builtin($<str>1); }
 706         | int_std
 707         | tSIGNED int_std                       { $$ = $2; $$->sign = 1; }
 708         | tUNSIGNED int_std                     { $$ = $2; $$->sign = -1;
 709                                                   switch ($$->type) {
 710                                                   case RPC_FC_CHAR:  break;
 711                                                   case RPC_FC_SMALL: $$->type = RPC_FC_USMALL; break;
 712                                                   case RPC_FC_SHORT: $$->type = RPC_FC_USHORT; break;
 713                                                   case RPC_FC_LONG:  $$->type = RPC_FC_ULONG;  break;
 714                                                   case RPC_FC_HYPER:
 715                                                     if ($$->name[0] == 'h') /* hyper, as opposed to __int64 */
 716                                                     {
 717                                                       $$ = alias($$, "MIDL_uhyper");
 718                                                       $$->sign = 0;
 719                                                     }
 720                                                     break;
 721                                                   default: break;
 722                                                   }
 723                                                 }
 724         | tUNSIGNED                             { $$ = make_int(-1); }
 725         | tFLOAT                                { $$ = make_builtin($<str>1); }
 726         | tSINGLE                               { $$ = duptype(find_type("float", 0), 1); }
 727         | tDOUBLE                               { $$ = make_builtin($<str>1); }
 728         | tBOOLEAN                              { $$ = make_builtin($<str>1); }
 729         | tERRORSTATUST                         { $$ = make_builtin($<str>1); }
 730         | tHANDLET                              { $$ = make_builtin($<str>1); }
 731         ;
 732
 733 m_int:
 734         | tINT
 735         ;
 736
 737 int_std:  tINT                                  { $$ = make_builtin($<str>1); }
 738         | tSHORT m_int                          { $$ = make_builtin($<str>1); }
 739         | tSMALL                                { $$ = make_builtin($<str>1); }
 740         | tLONG m_int                           { $$ = make_builtin($<str>1); }
 741         | tHYPER m_int                          { $$ = make_builtin($<str>1); }
 742         | tINT64                                { $$ = make_builtin($<str>1); }
 743         | tCHAR                                 { $$ = make_builtin($<str>1); }
 744         ;
 745
 746 coclass:  tCOCLASS aIDENTIFIER                  { $$ = make_class($2); }
 747         | tCOCLASS aKNOWNTYPE                   { $$ = find_type($2, 0);
 748                                                   if ($$->defined) error_loc("multiple definition error\n");
 749                                                   if ($$->kind != TKIND_COCLASS) error_loc("%s was not declared a coclass\n", $2);
 750                                                 }
 751         ;
 752
 753 coclasshdr: attributes coclass                  { $$ = $2;
 754                                                   $$->attrs = check_coclass_attrs($2->name, $1);
 755                                                   if (!parse_only && do_header)
 756                                                     write_coclass($$);
 757                                                   if (!parse_only && do_idfile)
 758                                                     write_clsid($$);
 759                                                 }
 760         ;
 761
 762 coclassdef: coclasshdr '{' coclass_ints '}' semicolon_opt
 763                                                 { $$ = $1;
 764                                                   $$->ifaces = $3;
 765                                                   $$->defined = TRUE;
 766                                                 }
 767         ;
 768
 769 coclass_ints:                                   { $$ = NULL; }
 770         | coclass_ints coclass_int              { $$ = append_ifref( $1, $2 ); }
 771         ;
 772
 773 coclass_int:
 774           m_attributes interfacedec             { $$ = make_ifref($2); $$->attrs = $1; }
 775         ;
 776
 777 dispinterface: tDISPINTERFACE aIDENTIFIER       { $$ = get_type(0, $2, 0); $$->kind = TKIND_DISPATCH; }
 778         |      tDISPINTERFACE aKNOWNTYPE        { $$ = get_type(0, $2, 0); $$->kind = TKIND_DISPATCH; }
 779         ;
 780
 781 dispinterfacehdr: attributes dispinterface      { attr_t *attrs;
 782                                                   is_object_interface = TRUE;
 783                                                   $$ = $2;
 784                                                   if ($$->defined) error_loc("multiple definition error\n");
 785                                                   attrs = make_attr(ATTR_DISPINTERFACE);
 786                                                   $$->attrs = append_attr( check_dispiface_attrs($2->name, $1), attrs );
 787                                                   $$->ref = find_type("IDispatch", 0);
 788                                                   if (!$$->ref) error_loc("IDispatch is undefined\n");
 789                                                   $$->defined = TRUE;
 790                                                   if (!parse_only && do_header) write_forward($$);
 791                                                 }
 792         ;
 793
 794 dispint_props: tPROPERTIES ':'                  { $$ = NULL; }
 795         | dispint_props s_field ';'             { $$ = append_var( $1, $2 ); }
 796         ;
 797
 798 dispint_meths: tMETHODS ':'                     { $$ = NULL; }
 799         | dispint_meths funcdef ';'             { $$ = append_func( $1, $2 ); }
 800         ;
 801
 802 dispinterfacedef: dispinterfacehdr '{'
 803           dispint_props
 804           dispint_meths
 805           '}'                                   { $$ = $1;
 806                                                   $$->fields_or_args = $3;
 807                                                   $$->funcs = $4;
 808                                                   if (!parse_only && do_header) write_dispinterface($$);
 809                                                   if (!parse_only && do_idfile) write_diid($$);
 810                                                 }
 811         | dispinterfacehdr
 812          '{' interface ';' '}'                  { $$ = $1;
 813                                                   $$->fields_or_args = $3->fields_or_args;
 814                                                   $$->funcs = $3->funcs;
 815                                                   if (!parse_only && do_header) write_dispinterface($$);
 816                                                   if (!parse_only && do_idfile) write_diid($$);
 817                                                 }
 818         ;
 819
 820 inherit:                                        { $$ = NULL; }
 821         | ':' aKNOWNTYPE                        { $$ = find_type2($2, 0); }
 822         ;
 823
 824 interface: tINTERFACE aIDENTIFIER               { $$ = get_type(RPC_FC_IP, $2, 0); $$->kind = TKIND_INTERFACE; }
 825         |  tINTERFACE aKNOWNTYPE                { $$ = get_type(RPC_FC_IP, $2, 0); $$->kind = TKIND_INTERFACE; }
 826         ;
 827
 828 interfacehdr: attributes interface              { $$.interface = $2;
 829                                                   $$.old_pointer_default = pointer_default;
 830                                                   if (is_attr($1, ATTR_POINTERDEFAULT))
 831                                                     pointer_default = get_attrv($1, ATTR_POINTERDEFAULT);
 832                                                   is_object_interface = is_object($1);
 833                                                   if ($2->defined) error_loc("multiple definition error\n");
 834                                                   $2->attrs = check_iface_attrs($2->name, $1);
 835                                                   $2->defined = TRUE;
 836                                                   if (!parse_only && do_header) write_forward($2);
 837                                                 }
 838         ;
 839
 840 interfacedef: interfacehdr inherit
 841           '{' int_statements '}' semicolon_opt  { $$ = $1.interface;
 842                                                   $$->ref = $2;
 843                                                   $$->funcs = $4;
 844                                                   check_functions($$);
 845                                                   compute_method_indexes($$);
 846                                                   if (!parse_only && do_header) write_interface($$);
 847                                                   if (!parse_only && local_stubs) write_locals(local_stubs, $$, TRUE);
 848                                                   if (!parse_only && do_idfile) write_iid($$);
 849                                                   pointer_default = $1.old_pointer_default;
 850                                                 }
 851 /* MIDL is able to import the definition of a base class from inside the
 852  * definition of a derived class, I'll try to support it with this rule */
 853         | interfacehdr ':' aIDENTIFIER
 854           '{' import int_statements '}'
 855            semicolon_opt                        { $$ = $1.interface;
 856                                                   $$->ref = find_type2($3, 0);
 857                                                   if (!$$->ref) error_loc("base class '%s' not found in import\n", $3);
 858                                                   $$->funcs = $6;
 859                                                   compute_method_indexes($$);
 860                                                   if (!parse_only && do_header) write_interface($$);
 861                                                   if (!parse_only && local_stubs) write_locals(local_stubs, $$, TRUE);
 862                                                   if (!parse_only && do_idfile) write_iid($$);
 863                                                   pointer_default = $1.old_pointer_default;
 864                                                 }
 865         | dispinterfacedef semicolon_opt        { $$ = $1; }
 866         ;
 867
 868 interfacedec:
 869           interface ';'                         { $$ = $1; if (!parse_only && do_header) write_forward($$); }
 870         | dispinterface ';'                     { $$ = $1; if (!parse_only && do_header) write_forward($$); }
 871         ;
 872
 873 module:   tMODULE aIDENTIFIER                   { $$ = make_type(0, NULL); $$->name = $2; $$->kind = TKIND_MODULE; }
 874         | tMODULE aKNOWNTYPE                    { $$ = make_type(0, NULL); $$->name = $2; $$->kind = TKIND_MODULE; }
 875         ;
 876
 877 modulehdr: attributes module                    { $$ = $2;
 878                                                   $$->attrs = check_module_attrs($2->name, $1);
 879                                                 }
 880         ;
 881
 882 moduledef: modulehdr '{' int_statements '}'
 883            semicolon_opt                        { $$ = $1;
 884                                                   $$->funcs = $3;
 885                                                   /* FIXME: if (!parse_only && do_header) write_module($$); */
 886                                                 }
 887         ;
 888
 889 pident:   '*' pident %prec PPTR                 { $$ = $2; $$->ptr_level++; }
 890         | tCONST pident                         { $$ = $2; /* FIXME */ }
 891         | callconv pident                       { $$ = $2;
 892                                                   if ($$->callconv) parser_warning("multiple calling conventions %s, %s for function %s\n", $$->callconv, $1, $$->var->name);
 893                                                   $$->callconv = $1;
 894                                                 }
 895         | direct_ident
 896         ;
 897
 898 func_ident: direct_ident '(' m_args ')'
 899                                                 { $$ = $1;
 900                                                   $1->args = $3;
 901                                                   $1->is_func = TRUE;
 902                                                 }
 903         ;
 904
 905 direct_ident: ident                             { $$ = make_pident($1); }
 906         | '(' pident ')'                        { $$ = $2; }
 907         | func_ident                            { $$ = $1;
 908                                                   $$->func_ptr_level = $$->ptr_level;
 909                                                   $$->ptr_level = 0;
 910                                                 }
 911         ;
 912
 913 pident_list:
 914         pident                                  { $$ = append_pident( NULL, $1 ); }
 915         | pident_list ',' pident                { $$ = append_pident( $1, $3 ); }
 916         ;
 917
 918 pointer_type:
 919           tREF                                  { $$ = RPC_FC_RP; }
 920         | tUNIQUE                               { $$ = RPC_FC_UP; }
 921         | tPTR                                  { $$ = RPC_FC_FP; }
 922         ;
 923
 924 structdef: tSTRUCT t_ident '{' fields '}'       { $$ = get_typev(RPC_FC_STRUCT, $2, tsSTRUCT);
 925                                                   /* overwrite RPC_FC_STRUCT with a more exact type */
 926                                                   $$->type = get_struct_type( $4 );
 927                                                   $$->kind = TKIND_RECORD;
 928                                                   $$->fields_or_args = $4;
 929                                                   $$->defined = TRUE;
 930                                                   if(in_typelib)
 931                                                       add_typelib_entry($$);
 932                                                 }
 933         ;
 934
 935 type:     tVOID                                 { $$ = duptype(find_type("void", 0), 1); }
 936         | aKNOWNTYPE                            { $$ = find_type($1, 0); }
 937         | base_type                             { $$ = $1; }
 938         | tCONST type                           { $$ = duptype($2, 1); $$->is_const = TRUE; }
 939         | enumdef                               { $$ = $1; }
 940         | tENUM aIDENTIFIER                     { $$ = find_type2($2, tsENUM); }
 941         | structdef                             { $$ = $1; }
 942         | tSTRUCT aIDENTIFIER                   { $$ = get_type(RPC_FC_STRUCT, $2, tsSTRUCT); }
 943         | uniondef                              { $$ = $1; }
 944         | tUNION aIDENTIFIER                    { $$ = find_type2($2, tsUNION); }
 945         | tSAFEARRAY '(' type ')'               { $$ = make_safearray($3); }
 946         ;
 947
 948 typedef: tTYPEDEF m_attributes type pident_list { reg_typedefs($3, $4, check_typedef_attrs($2));
 949                                                   process_typedefs($4);
 950                                                 }
 951         ;
 952
 953 uniondef: tUNION t_ident '{' fields '}'         { $$ = get_typev(RPC_FC_NON_ENCAPSULATED_UNION, $2, tsUNION);
 954                                                   $$->kind = TKIND_UNION;
 955                                                   $$->fields_or_args = $4;
 956                                                   $$->defined = TRUE;
 957                                                 }
 958         | tUNION t_ident
 959           tSWITCH '(' s_field ')'
 960           m_ident '{' cases '}'                 { var_t *u = $7;
 961                                                   $$ = get_typev(RPC_FC_ENCAPSULATED_UNION, $2, tsUNION);
 962                                                   $$->kind = TKIND_UNION;
 963                                                   if (!u) u = make_var( xstrdup("tagged_union") );
 964                                                   u->type = make_type(RPC_FC_NON_ENCAPSULATED_UNION, NULL);
 965                                                   u->type->kind = TKIND_UNION;
 966                                                   u->type->fields_or_args = $9;
 967                                                   u->type->defined = TRUE;
 968                                                   $$->fields_or_args = append_var( $$->fields_or_args, $5 );
 969                                                   $$->fields_or_args = append_var( $$->fields_or_args, u );
 970                                                   $$->defined = TRUE;
 971                                                 }
 972         ;
 973
 974 version:
 975           aNUM                                  { $$ = MAKEVERSION($1, 0); }
 976         | aNUM '.' aNUM                         { $$ = MAKEVERSION($1, $3); }
 977         ;
 978
 979 %%
 980
 981 static void decl_builtin(const char *name, unsigned char type)
 982 {
 983   type_t *t = make_type(type, NULL);
 984   t->name = xstrdup(name);
 985   reg_type(t, name, 0);
 986 }
 987
 988 static type_t *make_builtin(char *name)
 989 {
 990   /* NAME is strdup'd in the lexer */
 991   type_t *t = duptype(find_type(name, 0), 0);
 992   t->name = name;
 993   return t;
 994 }
 995
 996 static type_t *make_int(int sign)
 997 {
 998   type_t *t = duptype(find_type("int", 0), 1);
 999
1000   t->sign = sign;
1001   if (sign < 0)
1002     t->type = t->type == RPC_FC_LONG ? RPC_FC_ULONG : RPC_FC_USHORT;
1003
1004   return t;
1005 }
1006
1007 void init_types(void)
1008 {
1009   decl_builtin("void", 0);
1010   decl_builtin("byte", RPC_FC_BYTE);
1011   decl_builtin("wchar_t", RPC_FC_WCHAR);
1012   decl_builtin("int", RPC_FC_LONG);     /* win32 */
1013   decl_builtin("short", RPC_FC_SHORT);
1014   decl_builtin("small", RPC_FC_SMALL);
1015   decl_builtin("long", RPC_FC_LONG);
1016   decl_builtin("hyper", RPC_FC_HYPER);
1017   decl_builtin("__int64", RPC_FC_HYPER);
1018   decl_builtin("char", RPC_FC_CHAR);
1019   decl_builtin("float", RPC_FC_FLOAT);
1020   decl_builtin("double", RPC_FC_DOUBLE);
1021   decl_builtin("boolean", RPC_FC_BYTE);
1022   decl_builtin("error_status_t", RPC_FC_ERROR_STATUS_T);
1023   decl_builtin("handle_t", RPC_FC_BIND_PRIMITIVE);
1024 }
1025
1026 static str_list_t *append_str(str_list_t *list, char *str)
1027 {
1028     struct str_list_entry_t *entry;
1029
1030     if (!str) return list;
1031     if (!list)
1032     {
1033         list = xmalloc( sizeof(*list) );
1034         list_init( list );
1035     }
1036     entry = xmalloc( sizeof(*entry) );
1037     entry->str = str;
1038     list_add_tail( list, &entry->entry );
1039     return list;
1040 }
1041
1042 static attr_list_t *append_attr(attr_list_t *list, attr_t *attr)
1043 {
1044     attr_t *attr_existing;
1045     if (!attr) return list;
1046     if (!list)
1047     {
1048         list = xmalloc( sizeof(*list) );
1049         list_init( list );
1050     }
1051     LIST_FOR_EACH_ENTRY(attr_existing, list, attr_t, entry)
1052         if (attr_existing->type == attr->type)
1053         {
1054             parser_warning("duplicate attribute %s\n", get_attr_display_name(attr->type));
1055             /* use the last attribute, like MIDL does */
1056             list_remove(&attr_existing->entry);
1057             break;
1058         }
1059     list_add_tail( list, &attr->entry );
1060     return list;
1061 }
1062
1063 static attr_t *make_attr(enum attr_type type)
1064 {
1065   attr_t *a = xmalloc(sizeof(attr_t));
1066   a->type = type;
1067   a->u.ival = 0;
1068   return a;
1069 }
1070
1071 static attr_t *make_attrv(enum attr_type type, unsigned long val)
1072 {
1073   attr_t *a = xmalloc(sizeof(attr_t));
1074   a->type = type;
1075   a->u.ival = val;
1076   return a;
1077 }
1078
1079 static attr_t *make_attrp(enum attr_type type, void *val)
1080 {
1081   attr_t *a = xmalloc(sizeof(attr_t));
1082   a->type = type;
1083   a->u.pval = val;
1084   return a;
1085 }
1086
1087 static expr_t *make_expr(enum expr_type type)
1088 {
1089   expr_t *e = xmalloc(sizeof(expr_t));
1090   e->type = type;
1091   e->ref = NULL;
1092   e->u.lval = 0;
1093   e->is_const = FALSE;
1094   e->cval = 0;
1095   return e;
1096 }
1097
1098 static expr_t *make_exprl(enum expr_type type, long val)
1099 {
1100   expr_t *e = xmalloc(sizeof(expr_t));
1101   e->type = type;
1102   e->ref = NULL;
1103   e->u.lval = val;
1104   e->is_const = FALSE;
1105   /* check for numeric constant */
1106   if (type == EXPR_NUM || type == EXPR_HEXNUM || type == EXPR_TRUEFALSE) {
1107     /* make sure true/false value is valid */
1108     assert(type != EXPR_TRUEFALSE || val == 0 || val == 1);
1109     e->is_const = TRUE;
1110     e->cval = val;
1111   }
1112   return e;
1113 }
1114
1115 static expr_t *make_exprd(enum expr_type type, double val)
1116 {
1117   expr_t *e = xmalloc(sizeof(expr_t));
1118   e->type = type;
1119   e->ref = NULL;
1120   e->u.dval = val;
1121   e->is_const = TRUE;
1122   e->cval = val;
1123   return e;
1124 }
1125
1126 static expr_t *make_exprs(enum expr_type type, char *val)
1127 {
1128   expr_t *e;
1129   e = xmalloc(sizeof(expr_t));
1130   e->type = type;
1131   e->ref = NULL;
1132   e->u.sval = val;
1133   e->is_const = FALSE;
1134   /* check for predefined constants */
1135   if (type == EXPR_IDENTIFIER) {
1136     var_t *c = find_const(val, 0);
1137     if (c) {
1138       e->u.sval = c->name;
1139       free(val);
1140       e->is_const = TRUE;
1141       e->cval = c->eval->cval;
1142     }
1143   }
1144   return e;
1145 }
1146
1147 static expr_t *make_exprt(enum expr_type type, type_t *tref, expr_t *expr)
1148 {
1149   expr_t *e;
1150   e = xmalloc(sizeof(expr_t));
1151   e->type = type;
1152   e->ref = expr;
1153   e->u.tref = tref;
1154   e->is_const = FALSE;
1155   /* check for cast of constant expression */
1156   if (type == EXPR_SIZEOF) {
1157     switch (tref->type) {
1158       case RPC_FC_BYTE:
1159       case RPC_FC_CHAR:
1160       case RPC_FC_SMALL:
1161       case RPC_FC_USMALL:
1162         e->is_const = TRUE;
1163         e->cval = 1;
1164         break;
1165       case RPC_FC_WCHAR:
1166       case RPC_FC_USHORT:
1167       case RPC_FC_SHORT:
1168         e->is_const = TRUE;
1169         e->cval = 2;
1170         break;
1171       case RPC_FC_LONG:
1172       case RPC_FC_ULONG:
1173       case RPC_FC_FLOAT:
1174       case RPC_FC_ERROR_STATUS_T:
1175         e->is_const = TRUE;
1176         e->cval = 4;
1177         break;
1178       case RPC_FC_HYPER:
1179       case RPC_FC_DOUBLE:
1180         e->is_const = TRUE;
1181         e->cval = 8;
1182         break;
1183     }
1184   }
1185   if (type == EXPR_CAST && expr->is_const) {
1186     e->is_const = TRUE;
1187     e->cval = expr->cval;
1188   }
1189   return e;
1190 }
1191
1192 static expr_t *make_expr1(enum expr_type type, expr_t *expr)
1193 {
1194   expr_t *e;
1195   if (type == EXPR_ADDRESSOF && expr->type != EXPR_IDENTIFIER)
1196     error_loc("address-of operator applied to invalid expression\n");
1197   e = xmalloc(sizeof(expr_t));
1198   e->type = type;
1199   e->ref = expr;
1200   e->u.lval = 0;
1201   e->is_const = FALSE;
1202   /* check for compile-time optimization */
1203   if (expr->is_const) {
1204     e->is_const = TRUE;
1205     switch (type) {
1206     case EXPR_NEG:
1207       e->cval = -expr->cval;
1208       break;
1209     case EXPR_NOT:
1210       e->cval = ~expr->cval;
1211       break;
1212     default:
1213       e->is_const = FALSE;
1214       break;
1215     }
1216   }
1217   return e;
1218 }
1219
1220 static expr_t *make_expr2(enum expr_type type, expr_t *expr1, expr_t *expr2)
1221 {
1222   expr_t *e;
1223   e = xmalloc(sizeof(expr_t));
1224   e->type = type;
1225   e->ref = expr1;
1226   e->u.ext = expr2;
1227   e->is_const = FALSE;
1228   /* check for compile-time optimization */
1229   if (expr1->is_const && expr2->is_const) {
1230     e->is_const = TRUE;
1231     switch (type) {
1232     case EXPR_ADD:
1233       e->cval = expr1->cval + expr2->cval;
1234       break;
1235     case EXPR_SUB:
1236       e->cval = expr1->cval - expr2->cval;
1237       break;
1238     case EXPR_MOD:
1239       if (expr2->cval == 0) {
1240         error_loc("divide by zero in expression\n");
1241         e->cval = 0;
1242       } else
1243         e->cval = expr1->cval % expr2->cval;
1244       break;
1245     case EXPR_MUL:
1246       e->cval = expr1->cval * expr2->cval;
1247       break;
1248     case EXPR_DIV:
1249       if (expr2->cval == 0) {
1250         error_loc("divide by zero in expression\n");
1251         e->cval = 0;
1252       } else
1253         e->cval = expr1->cval / expr2->cval;
1254       break;
1255     case EXPR_OR:
1256       e->cval = expr1->cval | expr2->cval;
1257       break;
1258     case EXPR_AND:
1259       e->cval = expr1->cval & expr2->cval;
1260       break;
1261     case EXPR_SHL:
1262       e->cval = expr1->cval << expr2->cval;
1263       break;
1264     case EXPR_SHR:
1265       e->cval = expr1->cval >> expr2->cval;
1266       break;
1267     default:
1268       e->is_const = FALSE;
1269       break;
1270     }
1271   }
1272   return e;
1273 }
1274
1275 static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3)
1276 {
1277   expr_t *e;
1278   e = xmalloc(sizeof(expr_t));
1279   e->type = type;
1280   e->ref = expr1;
1281   e->u.ext = expr2;
1282   e->ext2 = expr3;
1283   e->is_const = FALSE;
1284   /* check for compile-time optimization */
1285   if (expr1->is_const && expr2->is_const && expr3->is_const) {
1286     e->is_const = TRUE;
1287     switch (type) {
1288     case EXPR_COND:
1289       e->cval = expr1->cval ? expr2->cval : expr3->cval;
1290       break;
1291     default:
1292       e->is_const = FALSE;
1293       break;
1294     }
1295   }
1296   return e;
1297 }
1298
1299 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr)
1300 {
1301     if (!expr) return list;
1302     if (!list)
1303     {
1304         list = xmalloc( sizeof(*list) );
1305         list_init( list );
1306     }
1307     list_add_tail( list, &expr->entry );
1308     return list;
1309 }
1310
1311 static array_dims_t *append_array(array_dims_t *list, expr_t *expr)
1312 {
1313     if (!expr) return list;
1314     if (!list)
1315     {
1316         list = xmalloc( sizeof(*list) );
1317         list_init( list );
1318     }
1319     list_add_tail( list, &expr->entry );
1320     return list;
1321 }
1322
1323 static struct list type_pool = LIST_INIT(type_pool);
1324 typedef struct
1325 {
1326   type_t data;
1327   struct list link;
1328 } type_pool_node_t;
1329
1330 type_t *alloc_type(void)
1331 {
1332   type_pool_node_t *node = xmalloc(sizeof *node);
1333   list_add_tail(&type_pool, &node->link);
1334   return &node->data;
1335 }
1336
1337 void set_all_tfswrite(int val)
1338 {
1339   type_pool_node_t *node;
1340   LIST_FOR_EACH_ENTRY(node, &type_pool, type_pool_node_t, link)
1341     node->data.tfswrite = val;
1342 }
1343
1344 static type_t *make_type(unsigned char type, type_t *ref)
1345 {
1346   type_t *t = alloc_type();
1347   t->name = NULL;
1348   t->kind = TKIND_PRIMITIVE;
1349   t->type = type;
1350   t->ref = ref;
1351   t->attrs = NULL;
1352   t->orig = NULL;
1353   t->funcs = NULL;
1354   t->fields_or_args = NULL;
1355   t->ifaces = NULL;
1356   t->dim = 0;
1357   t->size_is = NULL;
1358   t->length_is = NULL;
1359   t->typestring_offset = 0;
1360   t->ptrdesc = 0;
1361   t->declarray = FALSE;
1362   t->ignore = (parse_only != 0);
1363   t->is_const = FALSE;
1364   t->sign = 0;
1365   t->defined = FALSE;
1366   t->written = FALSE;
1367   t->user_types_registered = FALSE;
1368   t->tfswrite = FALSE;
1369   t->checked = FALSE;
1370   t->typelib_idx = -1;
1371   return t;
1372 }
1373
1374 static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr,
1375                      int top)
1376 {
1377   expr_list_t *sizes = get_attrp(v->attrs, ATTR_SIZEIS);
1378   expr_list_t *lengs = get_attrp(v->attrs, ATTR_LENGTHIS);
1379   int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE);
1380   int ptr_type = ptr_attr;
1381   int sizeless, has_varconf;
1382   expr_t *dim;
1383   type_t *atype, **ptype;
1384   int ptr_level = (pident ? pident->ptr_level : 0);
1385
1386   v->type = type;
1387
1388   if (!ptr_type && top)
1389     ptr_type = RPC_FC_RP;
1390
1391   for ( ; 0 < ptr_level; --ptr_level)
1392   {
1393     v->type = make_type(pointer_default, v->type);
1394     if (ptr_level == 1 && ptr_type && !arr)
1395     {
1396       v->type->type = ptr_type;
1397       ptr_type = 0;
1398     }
1399   }
1400
1401   if (ptr_type && !arr)
1402   {
1403     if (is_ptr(v->type))
1404     {
1405       if (v->type->type != ptr_type)
1406       {
1407         v->type = duptype(v->type, 1);
1408         v->type->type = ptr_type;
1409       }
1410     }
1411     else if (!arr && ptr_attr)
1412       error_loc("%s: pointer attribute applied to non-pointer type\n", v->name);
1413   }
1414
1415   if (pident && pident->is_func) {
1416     int func_ptr_level = pident->func_ptr_level;
1417     v->type = make_type(RPC_FC_FUNCTION, v->type);
1418     v->type->fields_or_args = pident->args;
1419     if (pident->callconv)
1420       v->type->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, pident->callconv));
1421     else if (is_object_interface) {
1422       static char *stdmethodcalltype;
1423       if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
1424       v->type->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
1425     }
1426     for (; func_ptr_level > 0; func_ptr_level--)
1427       v->type = make_type(ptr_type, v->type);
1428   }
1429
1430   sizeless = FALSE;
1431   if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry)
1432   {
1433     if (sizeless)
1434       error_loc("%s: only the first array dimension can be unspecified\n", v->name);
1435
1436     if (dim->is_const)
1437     {
1438       unsigned int align = 0;
1439       size_t size = type_memsize(v->type, &align);
1440
1441       if (dim->cval <= 0)
1442         error_loc("%s: array dimension must be positive\n", v->name);
1443
1444       if (0xffffffffuL / size < (unsigned long) dim->cval)
1445         error_loc("%s: total array size is too large\n", v->name);
1446       else if (0xffffuL < size * dim->cval)
1447         v->type = make_type(RPC_FC_LGFARRAY, v->type);
1448       else
1449         v->type = make_type(RPC_FC_SMFARRAY, v->type);
1450     }
1451     else
1452     {
1453       sizeless = TRUE;
1454       v->type = make_type(RPC_FC_CARRAY, v->type);
1455     }
1456
1457     v->type->declarray = TRUE;
1458     v->type->dim = dim->cval;
1459   }
1460
1461   ptype = &v->type;
1462   has_varconf = FALSE;
1463   if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry)
1464   {
1465     if (dim->type != EXPR_VOID)
1466     {
1467       has_varconf = TRUE;
1468       atype = *ptype = duptype(*ptype, 0);
1469
1470       if (atype->type == RPC_FC_SMFARRAY || atype->type == RPC_FC_LGFARRAY)
1471         error_loc("%s: cannot specify size_is for a fixed sized array\n", v->name);
1472
1473       if (atype->type != RPC_FC_CARRAY && !is_ptr(atype))
1474         error_loc("%s: size_is attribute applied to illegal type\n", v->name);
1475
1476       atype->type = RPC_FC_CARRAY;
1477       atype->size_is = dim;
1478     }
1479
1480     ptype = &(*ptype)->ref;
1481     if (*ptype == NULL)
1482       error_loc("%s: too many expressions in size_is attribute\n", v->name);
1483   }
1484
1485   ptype = &v->type;
1486   if (lengs) LIST_FOR_EACH_ENTRY(dim, lengs, expr_t, entry)
1487   {
1488     if (dim->type != EXPR_VOID)
1489     {
1490       has_varconf = TRUE;
1491       atype = *ptype = duptype(*ptype, 0);
1492
1493       if (atype->type == RPC_FC_SMFARRAY)
1494         atype->type = RPC_FC_SMVARRAY;
1495       else if (atype->type == RPC_FC_LGFARRAY)
1496         atype->type = RPC_FC_LGVARRAY;
1497       else if (atype->type == RPC_FC_CARRAY)
1498         atype->type = RPC_FC_CVARRAY;
1499       else
1500         error_loc("%s: length_is attribute applied to illegal type\n", v->name);
1501
1502       atype->length_is = dim;
1503     }
1504
1505     ptype = &(*ptype)->ref;
1506     if (*ptype == NULL)
1507       error_loc("%s: too many expressions in length_is attribute\n", v->name);
1508   }
1509
1510   if (has_varconf && !last_array(v->type))
1511   {
1512     ptype = &v->type;
1513     for (ptype = &v->type; is_array(*ptype); ptype = &(*ptype)->ref)
1514     {
1515       *ptype = duptype(*ptype, 0);
1516       (*ptype)->type = RPC_FC_BOGUS_ARRAY;
1517     }
1518   }
1519
1520   if (is_array(v->type))
1521   {
1522     const type_t *rt = v->type->ref;
1523     if (is_user_type(rt))
1524       v->type->type = RPC_FC_BOGUS_ARRAY;
1525     else
1526       switch (rt->type)
1527         {
1528         case RPC_FC_BOGUS_STRUCT:
1529         case RPC_FC_NON_ENCAPSULATED_UNION:
1530         case RPC_FC_ENCAPSULATED_UNION:
1531         case RPC_FC_ENUM16:
1532           v->type->type = RPC_FC_BOGUS_ARRAY;
1533           break;
1534           /* FC_RP should be above, but widl overuses these, and will break things.  */
1535         case RPC_FC_UP:
1536         case RPC_FC_RP:
1537           if (rt->ref->type == RPC_FC_IP)
1538             v->type->type = RPC_FC_BOGUS_ARRAY;
1539           break;
1540         }
1541   }
1542 }
1543
1544 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface)
1545 {
1546     if (!iface) return list;
1547     if (!list)
1548     {
1549         list = xmalloc( sizeof(*list) );
1550         list_init( list );
1551     }
1552     list_add_tail( list, &iface->entry );
1553     return list;
1554 }
1555
1556 static ifref_t *make_ifref(type_t *iface)
1557 {
1558   ifref_t *l = xmalloc(sizeof(ifref_t));
1559   l->iface = iface;
1560   l->attrs = NULL;
1561   return l;
1562 }
1563
1564 static var_list_t *append_var(var_list_t *list, var_t *var)
1565 {
1566     if (!var) return list;
1567     if (!list)
1568     {
1569         list = xmalloc( sizeof(*list) );
1570         list_init( list );
1571     }
1572     list_add_tail( list, &var->entry );
1573     return list;
1574 }
1575
1576 static var_t *make_var(char *name)
1577 {
1578   var_t *v = xmalloc(sizeof(var_t));
1579   v->name = name;
1580   v->type = NULL;
1581   v->attrs = NULL;
1582   v->eval = NULL;
1583   v->loc_info.input_name = input_name ? input_name : "stdin";
1584   v->loc_info.line_number = line_number;
1585   v->loc_info.near_text = parser_text;
1586   return v;
1587 }
1588
1589 static pident_list_t *append_pident(pident_list_t *list, pident_t *p)
1590 {
1591   if (!p) return list;
1592   if (!list) {
1593     list = xmalloc(sizeof(*list));
1594     list_init(list);
1595   }
1596   list_add_tail(list, &p->entry);
1597   return list;
1598 }
1599
1600 static pident_t *make_pident(var_t *var)
1601 {
1602   pident_t *p = xmalloc(sizeof(*p));
1603   p->var = var;
1604   p->is_func = FALSE;
1605   p->ptr_level = 0;
1606   p->func_ptr_level = 0;
1607   p->args = NULL;
1608   p->callconv = NULL;
1609   return p;
1610 }
1611
1612 static func_list_t *append_func(func_list_t *list, func_t *func)
1613 {
1614     if (!func) return list;
1615     if (!list)
1616     {
1617         list = xmalloc( sizeof(*list) );
1618         list_init( list );
1619     }
1620     list_add_tail( list, &func->entry );
1621     return list;
1622 }
1623
1624 static func_t *make_func(var_t *def, var_list_t *args)
1625 {
1626   func_t *f = xmalloc(sizeof(func_t));
1627   f->def = def;
1628   f->args = args;
1629   f->ignore = parse_only;
1630   f->idx = -1;
1631   return f;
1632 }
1633
1634 static type_t *make_class(char *name)
1635 {
1636   type_t *c = make_type(0, NULL);
1637   c->name = name;
1638   c->kind = TKIND_COCLASS;
1639   return c;
1640 }
1641
1642 static type_t *make_safearray(type_t *type)
1643 {
1644   type_t *sa = duptype(find_type("SAFEARRAY", 0), 1);
1645   sa->ref = type;
1646   return make_type(pointer_default, sa);
1647 }
1648
1649 #define HASHMAX 64
1650
1651 static int hash_ident(const char *name)
1652 {
1653   const char *p = name;
1654   int sum = 0;
1655   /* a simple sum hash is probably good enough */
1656   while (*p) {
1657     sum += *p;
1658     p++;
1659   }
1660   return sum & (HASHMAX-1);
1661 }
1662
1663 /***** type repository *****/
1664
1665 struct rtype {
1666   const char *name;
1667   type_t *type;
1668   int t;
1669   struct rtype *next;
1670 };
1671
1672 struct rtype *type_hash[HASHMAX];
1673
1674 static type_t *reg_type(type_t *type, const char *name, int t)
1675 {
1676   struct rtype *nt;
1677   int hash;
1678   if (!name) {
1679     error_loc("registering named type without name\n");
1680     return type;
1681   }
1682   hash = hash_ident(name);
1683   nt = xmalloc(sizeof(struct rtype));
1684   nt->name = name;
1685   nt->type = type;
1686   nt->t = t;
1687   nt->next = type_hash[hash];
1688   type_hash[hash] = nt;
1689   return type;
1690 }
1691
1692 static int is_incomplete(const type_t *t)
1693 {
1694   return !t->defined && (is_struct(t->type) || is_union(t->type));
1695 }
1696
1697 static void add_incomplete(type_t *t)
1698 {
1699   struct typenode *tn = xmalloc(sizeof *tn);
1700   tn->type = t;
1701   list_add_tail(&incomplete_types, &tn->entry);
1702 }
1703
1704 static void fix_type(type_t *t)
1705 {
1706   if (t->kind == TKIND_ALIAS && is_incomplete(t)) {
1707     type_t *ot = t->orig;
1708     fix_type(ot);
1709     t->fields_or_args = ot->fields_or_args;
1710     t->defined = ot->defined;
1711   }
1712 }
1713
1714 static void fix_incomplete(void)
1715 {
1716   struct typenode *tn, *next;
1717
1718   LIST_FOR_EACH_ENTRY_SAFE(tn, next, &incomplete_types, struct typenode, entry) {
1719     fix_type(tn->type);
1720     free(tn);
1721   }
1722 }
1723
1724 static type_t *reg_typedefs(type_t *type, pident_list_t *pidents, attr_list_t *attrs)
1725 {
1726   type_t *ptr = type;
1727   const pident_t *pident;
1728   int ptrc = 0;
1729   int is_str = is_attr(attrs, ATTR_STRING);
1730   unsigned char ptr_type = get_attrv(attrs, ATTR_POINTERTYPE);
1731
1732   if (is_str)
1733   {
1734     type_t *t = type;
1735     unsigned char c;
1736
1737     while (is_ptr(t))
1738       t = t->ref;
1739
1740     c = t->type;
1741     if (c != RPC_FC_CHAR && c != RPC_FC_BYTE && c != RPC_FC_WCHAR)
1742     {
1743       pident = LIST_ENTRY( list_head( pidents ), const pident_t, entry );
1744       error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
1745               pident->var->name);
1746     }
1747   }
1748
1749   /* We must generate names for tagless enum, struct or union.
1750      Typedef-ing a tagless enum, struct or union means we want the typedef
1751      to be included in a library whether it has other attributes or not,
1752      hence the public attribute.  */
1753   if ((type->kind == TKIND_ENUM || type->kind == TKIND_RECORD
1754        || type->kind == TKIND_UNION) && ! type->name && ! parse_only)
1755   {
1756     if (! is_attr(attrs, ATTR_PUBLIC))
1757       attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
1758     type->name = gen_name();
1759   }
1760
1761   LIST_FOR_EACH_ENTRY( pident, pidents, const pident_t, entry )
1762   {
1763     var_t *name = pident->var;
1764
1765     if (name->name) {
1766       type_t *cur = ptr;
1767       int cptr = pident->ptr_level;
1768       if (cptr > ptrc) {
1769         while (cptr > ptrc) {
1770           cur = ptr = make_type(pointer_default, cur);
1771           ptrc++;
1772         }
1773       } else {
1774         while (cptr < ptrc) {
1775           cur = cur->ref;
1776           cptr++;
1777         }
1778       }
1779       if (pident->is_func) {
1780         int func_ptr_level = pident->func_ptr_level;
1781         cur = make_type(RPC_FC_FUNCTION, cur);
1782         cur->fields_or_args = pident->args;
1783         if (pident->callconv)
1784           cur->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, pident->callconv));
1785         else if (is_object_interface) {
1786           static char *stdmethodcalltype;
1787           if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
1788           cur->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
1789         }
1790         for (; func_ptr_level > 0; func_ptr_level--)
1791           cur = make_type(pointer_default, cur);
1792       }
1793       cur = alias(cur, name->name);
1794       cur->attrs = attrs;
1795       if (ptr_type)
1796       {
1797         if (is_ptr(cur))
1798           cur->type = ptr_type;
1799         else
1800           error_loc("'%s': pointer attribute applied to non-pointer type\n",
1801                   cur->name);
1802       }
1803       else if (is_str && ! is_ptr(cur))
1804         error_loc("'%s': [string] attribute applied to non-pointer type\n",
1805                 cur->name);
1806
1807       if (is_incomplete(cur))
1808         add_incomplete(cur);
1809       reg_type(cur, cur->name, 0);
1810     }
1811   }
1812   return type;
1813 }
1814
1815 static type_t *find_type(const char *name, int t)
1816 {
1817   struct rtype *cur = type_hash[hash_ident(name)];
1818   while (cur && (cur->t != t || strcmp(cur->name, name)))
1819     cur = cur->next;
1820   if (!cur) {
1821     error_loc("type '%s' not found\n", name);
1822     return NULL;
1823   }
1824   return cur->type;
1825 }
1826
1827 static type_t *find_type2(char *name, int t)
1828 {
1829   type_t *tp = find_type(name, t);
1830   free(name);
1831   return tp;
1832 }
1833
1834 int is_type(const char *name)
1835 {
1836   struct rtype *cur = type_hash[hash_ident(name)];
1837   while (cur && (cur->t || strcmp(cur->name, name)))
1838     cur = cur->next;
1839   if (cur) return TRUE;
1840   return FALSE;
1841 }
1842
1843 static type_t *get_type(unsigned char type, char *name, int t)
1844 {
1845   struct rtype *cur = NULL;
1846   type_t *tp;
1847   if (name) {
1848     cur = type_hash[hash_ident(name)];
1849     while (cur && (cur->t != t || strcmp(cur->name, name)))
1850       cur = cur->next;
1851   }
1852   if (cur) {
1853     free(name);
1854     return cur->type;
1855   }
1856   tp = make_type(type, NULL);
1857   tp->name = name;
1858   if (!name) return tp;
1859   return reg_type(tp, name, t);
1860 }
1861
1862 static type_t *get_typev(unsigned char type, var_t *name, int t)
1863 {
1864   char *sname = NULL;
1865   if (name) {
1866     sname = name->name;
1867     free(name);
1868   }
1869   return get_type(type, sname, t);
1870 }
1871
1872 static int get_struct_type(var_list_t *fields)
1873 {
1874   int has_pointer = 0;
1875   int has_conformance = 0;
1876   int has_variance = 0;
1877   var_t *field;
1878
1879   if (get_padding(fields))
1880     return RPC_FC_BOGUS_STRUCT;
1881
1882   if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry )
1883   {
1884     type_t *t = field->type;
1885
1886     if (is_user_type(t))
1887       return RPC_FC_BOGUS_STRUCT;
1888
1889     if (is_ptr(t))
1890     {
1891         do
1892             t = t->ref;
1893         while (is_ptr(t));
1894
1895         switch (t->type)
1896         {
1897         case RPC_FC_IP:
1898         case RPC_FC_ENCAPSULATED_UNION:
1899         case RPC_FC_NON_ENCAPSULATED_UNION:
1900         case RPC_FC_BOGUS_STRUCT:
1901             return RPC_FC_BOGUS_STRUCT;
1902         }
1903
1904         has_pointer = 1;
1905         continue;
1906     }
1907
1908     if (field->type->declarray)
1909     {
1910         if (is_string_type(field->attrs, field->type))
1911         {
1912             if (is_conformant_array(field->type))
1913                 has_conformance = 1;
1914             has_variance = 1;
1915             continue;
1916         }
1917
1918         if (is_array(field->type->ref))
1919             return RPC_FC_BOGUS_STRUCT;
1920
1921         if (is_conformant_array(field->type))
1922         {
1923             has_conformance = 1;
1924             if (field->type->declarray && list_next(fields, &field->entry))
1925                 error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n",
1926                         field->name);
1927         }
1928         if (field->type->length_is)
1929             has_variance = 1;
1930
1931         t = field->type->ref;
1932     }
1933
1934     switch (t->type)
1935     {
1936     /*
1937      * RPC_FC_BYTE, RPC_FC_STRUCT, etc
1938      *  Simple types don't effect the type of struct.
1939      *  A struct containing a simple struct is still a simple struct.
1940      *  So long as we can block copy the data, we return RPC_FC_STRUCT.
1941      */
1942     case 0: /* void pointer */
1943     case RPC_FC_BYTE:
1944     case RPC_FC_CHAR:
1945     case RPC_FC_SMALL:
1946     case RPC_FC_USMALL:
1947     case RPC_FC_WCHAR:
1948     case RPC_FC_SHORT:
1949     case RPC_FC_USHORT:
1950     case RPC_FC_LONG:
1951     case RPC_FC_ULONG:
1952     case RPC_FC_INT3264:
1953     case RPC_FC_UINT3264:
1954     case RPC_FC_HYPER:
1955     case RPC_FC_FLOAT:
1956     case RPC_FC_DOUBLE:
1957     case RPC_FC_STRUCT:
1958     case RPC_FC_ENUM32:
1959       break;
1960
1961     case RPC_FC_RP:
1962     case RPC_FC_UP:
1963     case RPC_FC_FP:
1964     case RPC_FC_OP:
1965     case RPC_FC_CARRAY:
1966     case RPC_FC_CVARRAY:
1967     case RPC_FC_BOGUS_ARRAY:
1968       has_pointer = 1;
1969       break;
1970
1971     /*
1972      * Propagate member attributes
1973      *  a struct should be at least as complex as its member
1974      */
1975     case RPC_FC_CVSTRUCT:
1976       has_conformance = 1;
1977       has_variance = 1;
1978       has_pointer = 1;
1979       break;
1980
1981     case RPC_FC_CPSTRUCT:
1982       has_conformance = 1;
1983       if (list_next( fields, &field->entry ))
1984           error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n",
1985                   field->name);
1986       has_pointer = 1;
1987       break;
1988
1989     case RPC_FC_CSTRUCT:
1990       has_conformance = 1;
1991       if (list_next( fields, &field->entry ))
1992           error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n",
1993                   field->name);
1994       break;
1995
1996     case RPC_FC_PSTRUCT:
1997       has_pointer = 1;
1998       break;
1999
2000     default:
2001       error_loc("Unknown struct member %s with type (0x%02x)\n", field->name, t->type);
2002       /* fallthru - treat it as complex */
2003
2004     /* as soon as we see one of these these members, it's bogus... */
2005     case RPC_FC_ENCAPSULATED_UNION:
2006     case RPC_FC_NON_ENCAPSULATED_UNION:
2007     case RPC_FC_BOGUS_STRUCT:
2008     case RPC_FC_ENUM16:
2009       return RPC_FC_BOGUS_STRUCT;
2010     }
2011   }
2012
2013   if( has_variance )
2014   {
2015     if ( has_conformance )
2016       return RPC_FC_CVSTRUCT;
2017     else
2018       return RPC_FC_BOGUS_STRUCT;
2019   }
2020   if( has_conformance && has_pointer )
2021     return RPC_FC_CPSTRUCT;
2022   if( has_conformance )
2023     return RPC_FC_CSTRUCT;
2024   if( has_pointer )
2025     return RPC_FC_PSTRUCT;
2026   return RPC_FC_STRUCT;
2027 }
2028
2029 /***** constant repository *****/
2030
2031 struct rconst {
2032   char *name;
2033   var_t *var;
2034   struct rconst *next;
2035 };
2036
2037 struct rconst *const_hash[HASHMAX];
2038
2039 static var_t *reg_const(var_t *var)
2040 {
2041   struct rconst *nc;
2042   int hash;
2043   if (!var->name) {
2044     error_loc("registering constant without name\n");
2045     return var;
2046   }
2047   hash = hash_ident(var->name);
2048   nc = xmalloc(sizeof(struct rconst));
2049   nc->name = var->name;
2050   nc->var = var;
2051   nc->next = const_hash[hash];
2052   const_hash[hash] = nc;
2053   return var;
2054 }
2055
2056 static var_t *find_const(char *name, int f)
2057 {
2058   struct rconst *cur = const_hash[hash_ident(name)];
2059   while (cur && strcmp(cur->name, name))
2060     cur = cur->next;
2061   if (!cur) {
2062     if (f) error_loc("constant '%s' not found\n", name);
2063     return NULL;
2064   }
2065   return cur->var;
2066 }
2067
2068 static void write_libid(const char *name, const attr_list_t *attr)
2069 {
2070   const UUID *uuid = get_attrp(attr, ATTR_UUID);
2071   write_guid(idfile, "LIBID", name, uuid);
2072 }
2073
2074 static void write_clsid(type_t *cls)
2075 {
2076   const UUID *uuid = get_attrp(cls->attrs, ATTR_UUID);
2077   write_guid(idfile, "CLSID", cls->name, uuid);
2078 }
2079
2080 static void write_diid(type_t *iface)
2081 {
2082   const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
2083   write_guid(idfile, "DIID", iface->name, uuid);
2084 }
2085
2086 static void write_iid(type_t *iface)
2087 {
2088   const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
2089   write_guid(idfile, "IID", iface->name, uuid);
2090 }
2091
2092 static int compute_method_indexes(type_t *iface)
2093 {
2094   int idx;
2095   func_t *f;
2096
2097   if (iface->ref)
2098     idx = compute_method_indexes(iface->ref);
2099   else
2100     idx = 0;
2101
2102   if (!iface->funcs)
2103     return idx;
2104
2105   LIST_FOR_EACH_ENTRY( f, iface->funcs, func_t, entry )
2106     if (! is_callas(f->def->attrs))
2107       f->idx = idx++;
2108
2109   return idx;
2110 }
2111
2112 static char *gen_name(void)
2113 {
2114   static const char format[] = "__WIDL_%s_generated_name_%08lX";
2115   static unsigned long n = 0;
2116   static const char *file_id;
2117   static size_t size;
2118   char *name;
2119
2120   if (! file_id)
2121   {
2122     char *dst = dup_basename(input_name, ".idl");
2123     file_id = dst;
2124
2125     for (; *dst; ++dst)
2126       if (! isalnum((unsigned char) *dst))
2127         *dst = '_';
2128
2129     size = sizeof format - 7 + strlen(file_id) + 8;
2130   }
2131
2132   name = xmalloc(size);
2133   sprintf(name, format, file_id, n++);
2134   return name;
2135 }
2136
2137 static void process_typedefs(pident_list_t *pidents)
2138 {
2139   pident_t *pident, *next;
2140
2141   if (!pidents) return;
2142   LIST_FOR_EACH_ENTRY_SAFE( pident, next, pidents, pident_t, entry )
2143   {
2144     var_t *var = pident->var;
2145     type_t *type = find_type(var->name, 0);
2146
2147     if (! parse_only && do_header)
2148       write_typedef(type);
2149     if (in_typelib && type->attrs)
2150       add_typelib_entry(type);
2151
2152     free(pident);
2153     free(var);
2154   }
2155 }
2156
2157 struct allowed_attr
2158 {
2159     unsigned int dce_compatible : 1;
2160     unsigned int acf : 1;
2161     unsigned int on_interface : 1;
2162     unsigned int on_function : 1;
2163     unsigned int on_arg : 1;
2164     unsigned int on_type : 1;
2165     unsigned int on_field : 1;
2166     unsigned int on_library : 1;
2167     unsigned int on_dispinterface : 1;
2168     unsigned int on_module : 1;
2169     unsigned int on_coclass : 1;
2170     const char *display_name;
2171 };
2172
2173 struct allowed_attr allowed_attr[] =
2174 {
2175     /* attr                     { D ACF I Fn ARG T Fi  L  DI M  C  <display name> } */
2176     /* ATTR_AGGREGATABLE */     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "aggregatable" },
2177     /* ATTR_APPOBJECT */        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "appobject" },
2178     /* ATTR_ASYNC */            { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, "async" },
2179     /* ATTR_AUTO_HANDLE */      { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "auto_handle" },
2180     /* ATTR_BINDABLE */         { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "bindable" },
2181     /* ATTR_BROADCAST */        { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
2182     /* ATTR_CALLAS */           { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "call_as" },
2183     /* ATTR_CALLCONV */         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
2184     /* ATTR_CASE */             { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
2185     /* ATTR_CONTEXTHANDLE */    { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "context_handle" },
2186     /* ATTR_CONTROL */          { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
2187     /* ATTR_DEFAULT */          { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, "default" },
2188     /* ATTR_DEFAULTCOLLELEM */  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
2189     /* ATTR_DEFAULTVALUE_EXPR */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "defaultvalue" },
2190     /* ATTR_DEFAULTVALUE_STRING */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "defaultvalue" },
2191     /* ATTR_DEFAULTVTABLE */    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
2192     /* ATTR_DISPINTERFACE */    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
2193     /* ATTR_DISPLAYBIND */      { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
2194     /* ATTR_DLLNAME */          { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
2195     /* ATTR_DUAL */             { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
2196     /* ATTR_ENDPOINT */         { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
2197     /* ATTR_ENTRY_ORDINAL */    { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "entry" },
2198     /* ATTR_ENTRY_STRING */     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "entry" },
2199     /* ATTR_EXPLICIT_HANDLE */  { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
2200     /* ATTR_HANDLE */           { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "handle" },
2201     /* ATTR_HELPCONTEXT */      { 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, "helpcontext" },
2202     /* ATTR_HELPFILE */         { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpfile" },
2203     /* ATTR_HELPSTRING */       { 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, "helpstring" },
2204     /* ATTR_HELPSTRINGCONTEXT */ { 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, "helpstringcontext" },
2205     /* ATTR_HELPSTRINGDLL */    { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpstringdll" },
2206     /* ATTR_HIDDEN */           { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, "hidden" },
2207     /* ATTR_ID */               { 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, "id" },
2208     /* ATTR_IDEMPOTENT */       { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "idempotent" },
2209     /* ATTR_IIDIS */            { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, "iid_is" },
2210     /* ATTR_IMMEDIATEBIND */    { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
2211     /* ATTR_IMPLICIT_HANDLE */  { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
2212     /* ATTR_IN */               { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "in" },
2213     /* ATTR_INPUTSYNC */        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
2214     /* ATTR_LENGTHIS */         { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, "length_is" },
2215     /* ATTR_LOCAL */            { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, "local" },
2216     /* ATTR_NONBROWSABLE */     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
2217     /* ATTR_NONCREATABLE */     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
2218     /* ATTR_NONEXTENSIBLE */    { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "nonextensible" },
2219     /* ATTR_OBJECT */           { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "object" },
2220     /* ATTR_ODL */              { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, "odl" },
2221     /* ATTR_OLEAUTOMATION */    { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
2222     /* ATTR_OPTIONAL */         { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "optional" },
2223     /* ATTR_OUT */              { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "out" },
2224     /* ATTR_POINTERDEFAULT */   { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
2225     /* ATTR_POINTERTYPE */      { 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, "ref, unique or ptr" },
2226     /* ATTR_PROPGET */          { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "propget" },
2227     /* ATTR_PROPPUT */          { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "propput" },
2228     /* ATTR_PROPPUTREF */       { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "propputref" },
2229     /* ATTR_PUBLIC */           { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "public" },
2230     /* ATTR_RANGE */            { 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, "range" },
2231     /* ATTR_READONLY */         { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, "readonly" },
2232     /* ATTR_REQUESTEDIT */      { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "requestedit" },
2233     /* ATTR_RESTRICTED */       { 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, "restricted" },
2234     /* ATTR_RETVAL */           { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "retval" },
2235     /* ATTR_SIZEIS */           { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, "size_is" },
2236     /* ATTR_SOURCE */           { 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, "source" },
2237     /* ATTR_STRICTCONTEXTHANDLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "strict_context_handle" },
2238     /* ATTR_STRING */           { 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, "string" },
2239     /* ATTR_SWITCHIS */         { 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, "switch_is" },
2240     /* ATTR_SWITCHTYPE */       { 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, "switch_type" },
2241     /* ATTR_TRANSMITAS */       { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "transmit_as" },
2242     /* ATTR_UUID */             { 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, "uuid" },
2243     /* ATTR_V1ENUM */           { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "v1_enum" },
2244     /* ATTR_VARARG */           { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "vararg" },
2245     /* ATTR_VERSION */          { 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, "version" },
2246     /* ATTR_WIREMARSHAL */      { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "wire_marshal" },
2247 };
2248
2249 const char *get_attr_display_name(enum attr_type type)
2250 {
2251     return allowed_attr[type].display_name;
2252 }
2253
2254 static const attr_list_t *check_iface_attrs(const char *name, const attr_list_t *attrs)
2255 {
2256   const attr_t *attr;
2257   if (!attrs) return attrs;
2258   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2259   {
2260     if (!allowed_attr[attr->type].on_interface)
2261       error_loc("inapplicable attribute %s for interface %s\n",
2262                 allowed_attr[attr->type].display_name, name);
2263   }
2264   return attrs;
2265 }
2266
2267 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs)
2268 {
2269   const attr_t *attr;
2270   if (!attrs) return attrs;
2271   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2272   {
2273     if (!allowed_attr[attr->type].on_function)
2274       error_loc("inapplicable attribute %s for function %s\n",
2275                 allowed_attr[attr->type].display_name, name);
2276   }
2277   return attrs;
2278 }
2279
2280 static void check_arg(var_t *arg)
2281 {
2282   const type_t *t = arg->type;
2283   const attr_t *attr;
2284
2285   if (t->type == 0 && ! is_var_ptr(arg))
2286     error_loc("argument '%s' has void type\n", arg->name);
2287
2288   if (arg->attrs)
2289   {
2290     LIST_FOR_EACH_ENTRY(attr, arg->attrs, const attr_t, entry)
2291     {
2292       if (!allowed_attr[attr->type].on_arg)
2293         error_loc("inapplicable attribute %s for argument %s\n",
2294                   allowed_attr[attr->type].display_name, arg->name);
2295     }
2296   }
2297 }
2298
2299 static attr_list_t *check_typedef_attrs(attr_list_t *attrs)
2300 {
2301   const attr_t *attr;
2302   if (!attrs) return attrs;
2303   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2304   {
2305     if (!allowed_attr[attr->type].on_type)
2306       error_loc("inapplicable attribute %s for typedef\n",
2307                 allowed_attr[attr->type].display_name);
2308   }
2309   return attrs;
2310 }
2311
2312 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs)
2313 {
2314   const attr_t *attr;
2315   if (!attrs) return attrs;
2316   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2317   {
2318     if (!allowed_attr[attr->type].on_field)
2319       error_loc("inapplicable attribute %s for field %s\n",
2320                 allowed_attr[attr->type].display_name, name);
2321   }
2322   return attrs;
2323 }
2324
2325 static const attr_list_t *check_library_attrs(const char *name, const attr_list_t *attrs)
2326 {
2327   const attr_t *attr;
2328   if (!attrs) return attrs;
2329   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2330   {
2331     if (!allowed_attr[attr->type].on_library)
2332       error_loc("inapplicable attribute %s for library %s\n",
2333                 allowed_attr[attr->type].display_name, name);
2334   }
2335   return attrs;
2336 }
2337
2338 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs)
2339 {
2340   const attr_t *attr;
2341   if (!attrs) return attrs;
2342   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2343   {
2344     if (!allowed_attr[attr->type].on_dispinterface)
2345       error_loc("inapplicable attribute %s for dispinterface %s\n",
2346                 allowed_attr[attr->type].display_name, name);
2347   }
2348   return attrs;
2349 }
2350
2351 static const attr_list_t *check_module_attrs(const char *name, const attr_list_t *attrs)
2352 {
2353   const attr_t *attr;
2354   if (!attrs) return attrs;
2355   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2356   {
2357     if (!allowed_attr[attr->type].on_module)
2358       error_loc("inapplicable attribute %s for module %s\n",
2359                 allowed_attr[attr->type].display_name, name);
2360   }
2361   return attrs;
2362 }
2363
2364 static const attr_list_t *check_coclass_attrs(const char *name, const attr_list_t *attrs)
2365 {
2366   const attr_t *attr;
2367   if (!attrs) return attrs;
2368   LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2369   {
2370     if (!allowed_attr[attr->type].on_coclass)
2371       error_loc("inapplicable attribute %s for coclass %s\n",
2372                 allowed_attr[attr->type].display_name, name);
2373   }
2374   return attrs;
2375 }
2376
2377 static void check_remoting_fields(type_t *type);
2378
2379 /* checks that properties common to fields and arguments are consistent */
2380 static void check_field_common(const char *container_type,
2381                                const char *container_name, const var_t *arg)
2382 {
2383     type_t *type = arg->type;
2384     int is_wire_marshal = 0;
2385     int is_context_handle = 0;
2386
2387     if (is_attr(arg->attrs, ATTR_LENGTHIS) &&
2388         (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->type, ATTR_STRING)))
2389         error_loc_info(&arg->loc_info,
2390                        "string and length_is specified for argument %s are mutually exclusive attributes\n",
2391                        arg->name);
2392
2393     /* get fundamental type for the argument */
2394     for (;;)
2395     {
2396         if (is_attr(type->attrs, ATTR_WIREMARSHAL))
2397         {
2398             is_wire_marshal = 1;
2399             break;
2400         }
2401         if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
2402         {
2403             is_context_handle = 1;
2404             break;
2405         }
2406         if (type->kind == TKIND_ALIAS)
2407             type = type->orig;
2408         else if (is_ptr(type) || is_array(type))
2409             type = type->ref;
2410         else
2411             break;
2412     }
2413
2414     if (type->type == 0 && !is_attr(arg->attrs, ATTR_IIDIS) && !is_wire_marshal && !is_context_handle)
2415         error_loc_info(&arg->loc_info, "parameter \'%s\' of %s \'%s\' cannot derive from void *\n", arg->name, container_type, container_name);
2416     else if (type->type == RPC_FC_FUNCTION)
2417         error_loc_info(&arg->loc_info, "parameter \'%s\' of %s \'%s\' cannot be a function pointer\n", arg->name, container_type, container_name);
2418     else if (!is_wire_marshal && (is_struct(type->type) || is_union(type->type)))
2419         check_remoting_fields(type);
2420 }
2421
2422 static void check_remoting_fields(type_t *type)
2423 {
2424     const char *container_type = NULL;
2425     const var_t *field;
2426     const var_list_t *fields = NULL;
2427
2428     if (type->checked)
2429         return;
2430
2431     type->checked = TRUE;
2432
2433     if (is_struct(type->type))
2434     {
2435         fields = type->fields_or_args;
2436         container_type = "structure";
2437     }
2438     else if (is_union(type->type))
2439     {
2440         if (type->type == RPC_FC_ENCAPSULATED_UNION)
2441         {
2442             const var_t *uv = LIST_ENTRY(list_tail(type->fields_or_args), const var_t, entry);
2443             fields = uv->type->fields_or_args;
2444         }
2445         else
2446             fields = type->fields_or_args;
2447         container_type = "union";
2448     }
2449
2450     if (fields) LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
2451         if (field->type) check_field_common(container_type, type->name, field);
2452 }
2453
2454 /* checks that arguments for a function make sense for marshalling and unmarshalling */
2455 static void check_remoting_args(const func_t *func)
2456 {
2457     const char *funcname = func->def->name;
2458     const var_t *arg;
2459
2460     if (func->args) LIST_FOR_EACH_ENTRY( arg, func->args, const var_t, entry )
2461     {
2462         int ptr_level = 0;
2463         const type_t *type = arg->type;
2464
2465         /* get pointer level and fundamental type for the argument */
2466         for (;;)
2467         {
2468             if (is_attr(type->attrs, ATTR_WIREMARSHAL))
2469                 break;
2470             if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
2471                 break;
2472             if (type->kind == TKIND_ALIAS)
2473                 type = type->orig;
2474             else if (is_ptr(type))
2475             {
2476                 ptr_level++;
2477                 type = type->ref;
2478             }
2479             else
2480                 break;
2481         }
2482
2483         /* check that [out] parameters have enough pointer levels */
2484         if (is_attr(arg->attrs, ATTR_OUT))
2485         {
2486             if (!is_array(type))
2487             {
2488                 if (!ptr_level)
2489                     error_loc_info(&arg->loc_info, "out parameter \'%s\' of function \'%s\' is not a pointer\n", arg->name, funcname);
2490                 if (type->type == RPC_FC_IP && ptr_level == 1)
2491                     error_loc_info(&arg->loc_info, "out interface pointer \'%s\' of function \'%s\' is not a double pointer\n", arg->name, funcname);
2492             }
2493         }
2494
2495         check_field_common("function", funcname, arg);
2496     }
2497 }
2498
2499 static void add_explicit_handle_if_necessary(func_t *func)
2500 {
2501     const var_t* explicit_handle_var;
2502     const var_t* explicit_generic_handle_var = NULL;
2503     const var_t* context_handle_var = NULL;
2504
2505     /* check for a defined binding handle */
2506     explicit_handle_var = get_explicit_handle_var(func);
2507     if (!explicit_handle_var)
2508     {
2509         explicit_generic_handle_var = get_explicit_generic_handle_var(func);
2510         if (!explicit_generic_handle_var)
2511         {
2512             context_handle_var = get_context_handle_var(func);
2513             if (!context_handle_var)
2514             {
2515                 /* no explicit handle specified so add
2516                  * "[in] handle_t IDL_handle" as the first parameter to the
2517                  * function */
2518                 var_t *idl_handle = make_var(xstrdup("IDL_handle"));
2519                 idl_handle->attrs = append_attr(NULL, make_attr(ATTR_IN));
2520                 idl_handle->type = find_type("handle_t", 0);
2521                 if (!func->def->type->fields_or_args)
2522                 {
2523                     func->def->type->fields_or_args = xmalloc( sizeof(*func->def->type->fields_or_args) );
2524                     list_init( func->def->type->fields_or_args );
2525                 }
2526                 list_add_head( func->def->type->fields_or_args, &idl_handle->entry );
2527                 func->args = func->def->type->fields_or_args;
2528             }
2529         }
2530     }
2531 }
2532
2533 static void check_functions(const type_t *iface)
2534 {
2535     if (is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE) && iface->funcs)
2536     {
2537         func_t *func;
2538         LIST_FOR_EACH_ENTRY( func, iface->funcs, func_t, entry )
2539             add_explicit_handle_if_necessary(func);
2540     }
2541     if (!is_inside_library && !is_attr(iface->attrs, ATTR_LOCAL))
2542     {
2543         const func_t *func;
2544         if (iface->funcs) LIST_FOR_EACH_ENTRY( func, iface->funcs, const func_t, entry )
2545         {
2546             if (!is_attr(func->def->attrs, ATTR_LOCAL))
2547                 check_remoting_args(func);
2548         }
2549     }
2550 }
2551
2552 static void check_all_user_types(ifref_list_t *ifrefs)
2553 {
2554   const ifref_t *ifref;
2555   const func_t *f;
2556
2557   if (ifrefs) LIST_FOR_EACH_ENTRY(ifref, ifrefs, const ifref_t, entry)
2558   {
2559     const func_list_t *fs = ifref->iface->funcs;
2560     if (fs) LIST_FOR_EACH_ENTRY(f, fs, const func_t, entry)
2561       check_for_additional_prototype_types(f->args);
2562   }
2563 }
2564
2565 int is_valid_uuid(const char *s)
2566 {
2567   int i;
2568
2569   for (i = 0; i < 36; ++i)
2570     if (i == 8 || i == 13 || i == 18 || i == 23)
2571     {
2572       if (s[i] != '-')
2573         return FALSE;
2574     }
2575     else
2576       if (!isxdigit(s[i]))
2577         return FALSE;
2578
2579   return s[i] == '\0';
2580 }