[WIDL]
authorEric Kohl <eric.kohl@reactos.org>
Tue, 12 Oct 2010 20:51:07 +0000 (20:51 +0000)
committerEric Kohl <eric.kohl@reactos.org>
Tue, 12 Oct 2010 20:51:07 +0000 (20:51 +0000)
Update widl to version 1.3.4.

svn path=/trunk/; revision=49132

13 files changed:
reactos/media/doc/README.WINE
reactos/tools/widl/expr.c
reactos/tools/widl/header.c
reactos/tools/widl/header.h
reactos/tools/widl/parser.tab.c
reactos/tools/widl/parser.tab.h
reactos/tools/widl/parser.y
reactos/tools/widl/parser.yy.c
reactos/tools/widl/proxy.c
reactos/tools/widl/typegen.c
reactos/tools/widl/widl.c
reactos/tools/widl/widl_ros.diff
reactos/tools/widl/widltypes.h

index 62f4d2e..bc99050 100644 (file)
@@ -22,7 +22,7 @@ When porting a new DLL from Wine to ReactOS, please do the following steps
 The following build tools are shared with Wine.
 
 reactos/tools/unicode             # Synced to Wine-1_2rc6
-reactos/tools/widl                # Synced to Wine-1_2rc6
+reactos/tools/widl                # Synced to Wine-1_3_4
 reactos/tools/winebuild           # Synced to Wine-1_1_13
 reactos/tools/wmc                 # Synced to Wine-20081105 (~Wine-1.1.7)
 reactos/tools/wpp                 # Synced to Wine-20081105 (~Wine-1.1.7)
index 8511ce5..e1a5196 100644 (file)
@@ -513,27 +513,22 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc
     case EXPR_HEXNUM:
     case EXPR_NUM:
     case EXPR_TRUEFALSE:
-        result.is_variable = FALSE;
         result.is_temporary = FALSE;
         result.type = type_new_int(TYPE_BASIC_INT, 0);
         break;
     case EXPR_STRLIT:
-        result.is_variable = FALSE;
         result.is_temporary = TRUE;
         result.type = type_new_pointer(RPC_FC_UP, type_new_int(TYPE_BASIC_CHAR, 0), NULL);
         break;
     case EXPR_WSTRLIT:
-        result.is_variable = FALSE;
         result.is_temporary = TRUE;
         result.type = type_new_pointer(RPC_FC_UP, type_new_int(TYPE_BASIC_WCHAR, 0), NULL);
         break;
     case EXPR_CHARCONST:
-        result.is_variable = FALSE;
         result.is_temporary = TRUE;
         result.type = type_new_int(TYPE_BASIC_CHAR, 0);
         break;
     case EXPR_DOUBLE:
-        result.is_variable = FALSE;
         result.is_temporary = TRUE;
         result.type = type_new_basic(TYPE_BASIC_DOUBLE);
         break;
@@ -596,7 +591,6 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc
         result.type = e->u.tref;
         break;
     case EXPR_SIZEOF:
-        result.is_variable = FALSE;
         result.is_temporary = FALSE;
         result.type = type_new_int(TYPE_BASIC_INT, 0);
         break;
@@ -634,7 +628,6 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc
         result_right = resolve_expression(expr_loc, cont_type, e->u.ext);
         check_scalar_type(expr_loc, cont_type, result_left.type);
         check_scalar_type(expr_loc, cont_type, result_right.type);
-        result.is_variable = FALSE;
         result.is_temporary = FALSE;
         result.type = type_new_int(TYPE_BASIC_INT, 0);
         break;
index 91ea2a0..eaef867 100644 (file)
 typedef struct _user_type_t generic_handle_t;
 
 static int indentation = 0;
+static int is_object_interface = 0;
 user_type_list_t user_type_list = LIST_INIT(user_type_list);
 static context_handle_list_t context_handle_list = LIST_INIT(context_handle_list);
 static struct list generic_handle_list = LIST_INIT(generic_handle_list);
 
+static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name);
+
 static void indent(FILE *h, int delta)
 {
   int c;
@@ -366,12 +369,12 @@ static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const c
     if (type_get_type_detect_alias(pt) == TYPE_FUNCTION) {
       int i;
       const char *callconv = get_attrp(pt->attrs, ATTR_CALLCONV);
-      if (!callconv) callconv = "";
+      if (!callconv && is_object_interface) callconv = "STDMETHODCALLTYPE";
       if (is_attr(pt->attrs, ATTR_INLINE)) fprintf(h, "inline ");
       write_type_left(h, type_function_get_rettype(pt), declonly);
       fputc(' ', h);
       if (ptr_level) fputc('(', h);
-      fprintf(h, "%s ", callconv);
+      if (callconv) fprintf(h, "%s ", callconv);
       for (i = 0; i < ptr_level; i++)
         fputc('*', h);
     } else
@@ -396,7 +399,7 @@ static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const c
   }
 }
 
-void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
+static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
 {
   write_type_v(f, t, field, FALSE, name);
 }
@@ -785,7 +788,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface)
     const var_t *func = stmt->u.var;
     if (!is_callas(func->attrs)) {
       const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
-      if (!callconv) callconv = "";
+      if (!callconv) callconv = "STDMETHODCALLTYPE";
       indent(header, 0);
       fprintf(header, "virtual ");
       write_type_decl_left(header, type_function_get_rettype(func->type));
@@ -815,7 +818,7 @@ static void do_write_c_method_def(FILE *header, const type_t *iface, const char
     }
     if (!is_callas(func->attrs)) {
       const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
-      if (!callconv) callconv = "";
+      if (!callconv) callconv = "STDMETHODCALLTYPE";
       indent(header, 0);
       write_type_decl_left(header, type_function_get_rettype(func->type));
       fprintf(header, " (%s *%s)(\n", callconv, get_name(func));
@@ -846,7 +849,7 @@ static void write_method_proto(FILE *header, const type_t *iface)
 
     if (!is_local(func->attrs)) {
       const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
-      if (!callconv) callconv = "";
+      if (!callconv) callconv = "STDMETHODCALLTYPE";
       /* proxy prototype */
       write_type_decl_left(header, type_function_get_rettype(func->type));
       fprintf(header, " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func));
@@ -1217,6 +1220,7 @@ static void write_header_stmts(FILE *header, const statement_list_t *stmts, cons
         if (type_get_type(stmt->u.type) == TYPE_INTERFACE)
         {
           type_t *iface = stmt->u.type;
+          if (is_object(iface)) is_object_interface++;
           if (is_attr(stmt->u.type->attrs, ATTR_DISPINTERFACE) || is_object(stmt->u.type))
           {
             write_com_interface_start(header, iface);
@@ -1229,6 +1233,7 @@ static void write_header_stmts(FILE *header, const statement_list_t *stmts, cons
             write_header_stmts(header, type_iface_get_stmts(iface), iface, FALSE);
             write_rpc_interface_end(header, iface);
           }
+          if (is_object(iface)) is_object_interface++;
         }
         else if (type_get_type(stmt->u.type) == TYPE_COCLASS)
           write_coclass(header, stmt->u.type);
@@ -1304,16 +1309,14 @@ void write_header(const statement_list_t *stmts)
 
   fprintf(header, "#ifndef __WIDL_%s\n", header_token);
   fprintf(header, "#define __WIDL_%s\n\n", header_token);
-  start_cplusplus_guard(header);
-
-  fprintf(header, "/* Headers for imported files */\n\n");
-  write_imports(header, stmts);
-  fprintf(header, "\n");
 
-  /* FIXME: should be before imported file includes */
   fprintf(header, "/* Forward declarations */\n\n");
   write_forward_decls(header, stmts);
+
+  fprintf(header, "/* Headers for imported files */\n\n");
+  write_imports(header, stmts);
   fprintf(header, "\n");
+  start_cplusplus_guard(header);
 
   write_header_stmts(header, stmts, NULL, FALSE);
 
index 97a2726..2175f5e 100644 (file)
@@ -34,7 +34,6 @@ extern int is_declptr(const type_t *t);
 extern const char* get_name(const var_t *v);
 extern void write_type_left(FILE *h, type_t *t, int declonly);
 extern void write_type_right(FILE *h, type_t *t, int is_field);
-extern void write_type_def_or_decl(FILE *h, type_t *t, int is_field, const char *name);
 extern void write_type_decl(FILE *f, type_t *t, const char *name);
 extern void write_type_decl_left(FILE *f, type_t *t);
 extern int needs_space_after(type_t *t);
index 057bab5..5c9137b 100644 (file)
 #define YYERROR_VERBOSE
 
 static unsigned char pointer_default = RPC_FC_UP;
-static int is_object_interface = FALSE;
 
 typedef struct list typelist_t;
 struct typenode {
@@ -232,7 +231,7 @@ static statement_list_t *append_statement(statement_list_t *list, statement_t *s
 
 
 /* Line 189 of yacc.c  */
-#line 228 "parser.tab.c"
+#line 235 "parser.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -421,7 +420,7 @@ typedef union YYSTYPE
 {
 
 /* Line 214 of yacc.c  */
-#line 154 "parser.y"
+#line 153 "parser.y"
 
        attr_t *attr;
        attr_list_t *attr_list;
@@ -451,7 +450,7 @@ typedef union YYSTYPE
 
 
 /* Line 214 of yacc.c  */
-#line 447 "parser.tab.c"
+#line 454 "parser.tab.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -463,7 +462,7 @@ typedef union YYSTYPE
 
 
 /* Line 264 of yacc.c  */
-#line 459 "parser.tab.c"
+#line 466 "parser.tab.c"
 
 #ifdef short
 # undef short
@@ -897,36 +896,36 @@ static const yytype_int16 yyrhs[] =
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   326,   326,   339,   340,   341,   342,   345,   348,   349,
-     350,   353,   354,   355,   356,   357,   360,   361,   362,   363,
-     366,   367,   370,   371,   375,   376,   377,   378,   379,   383,
-     384,   385,   386,   387,   388,   391,   393,   401,   407,   411,
-     413,   417,   424,   425,   428,   429,   432,   433,   437,   442,
-     449,   450,   453,   454,   458,   461,   462,   463,   466,   467,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   521,   522,   523,   524,   525,   529,   530,   531,   532,
-     533,   534,   535,   536,   537,   538,   539,   540,   541,   542,
-     543,   544,   545,   549,   550,   555,   556,   557,   558,   561,
-     562,   565,   569,   575,   576,   577,   580,   584,   593,   597,
-     602,   605,   606,   619,   620,   623,   624,   625,   626,   627,
-     628,   629,   630,   631,   632,   633,   634,   635,   636,   637,
-     638,   639,   640,   641,   642,   643,   644,   645,   646,   647,
-     648,   649,   650,   651,   652,   653,   654,   655,   656,   657,
-     658,   659,   660,   662,   664,   665,   668,   669,   672,   678,
-     684,   685,   688,   693,   700,   701,   704,   705,   709,   710,
-     713,   719,   727,   731,   736,   737,   740,   741,   742,   745,
-     747,   750,   751,   752,   753,   754,   755,   756,   757,   758,
-     759,   760,   763,   764,   767,   768,   769,   770,   771,   772,
-     773,   774,   777,   778,   786,   792,   796,   797,   801,   804,
-     805,   808,   818,   819,   822,   823,   826,   832,   838,   839,
-     842,   843,   846,   857,   864,   870,   874,   875,   878,   879,
-     882,   887,   894,   895,   896,   900,   904,   907,   908,   911,
-     912,   916,   917,   921,   922,   923,   927,   929,   930,   934,
-     935,   936,   937,   945,   947,   948,   953,   955,   959,   960,
+       0,   325,   325,   338,   339,   340,   341,   344,   347,   348,
+     349,   352,   353,   354,   355,   356,   359,   360,   361,   362,
+     365,   366,   369,   370,   374,   375,   376,   377,   378,   382,
+     383,   384,   385,   386,   387,   390,   392,   400,   406,   410,
+     412,   416,   423,   424,   427,   428,   431,   432,   436,   441,
+     448,   449,   452,   453,   457,   460,   461,   462,   465,   466,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,   488,
+     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
+     499,   500,   501,   502,   503,   504,   505,   506,   507,   508,
+     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
+     519,   520,   521,   522,   523,   524,   528,   529,   530,   531,
+     532,   533,   534,   535,   536,   537,   538,   539,   540,   541,
+     542,   543,   544,   548,   549,   554,   555,   556,   557,   560,
+     561,   564,   568,   574,   575,   576,   579,   583,   592,   596,
+     601,   604,   605,   618,   619,   622,   623,   624,   625,   626,
+     627,   628,   629,   630,   631,   632,   633,   634,   635,   636,
+     637,   638,   639,   640,   641,   642,   643,   644,   645,   646,
+     647,   648,   649,   650,   651,   652,   653,   654,   655,   656,
+     657,   658,   659,   661,   663,   664,   667,   668,   671,   677,
+     683,   684,   687,   692,   699,   700,   703,   704,   708,   709,
+     712,   718,   726,   730,   735,   736,   739,   740,   741,   744,
+     746,   749,   750,   751,   752,   753,   754,   755,   756,   757,
+     758,   759,   762,   763,   766,   767,   768,   769,   770,   771,
+     772,   773,   776,   777,   785,   791,   795,   796,   800,   803,
+     804,   807,   816,   817,   820,   821,   824,   830,   836,   837,
+     840,   841,   844,   854,   861,   867,   871,   872,   875,   876,
+     879,   884,   891,   892,   893,   897,   901,   904,   905,   908,
+     909,   913,   914,   918,   919,   920,   924,   926,   928,   932,
+     933,   934,   935,   943,   945,   947,   952,   954,   959,   960,
      965,   966,   967,   968,   973,   982,   984,   985,   990,   992,
      996,   997,  1004,  1005,  1006,  1007,  1008,  1013,  1021,  1022,
     1025,  1026,  1029,  1036,  1037,  1042,  1043,  1047,  1048,  1049,
@@ -2654,7 +2653,7 @@ yyreduce:
         case 2:
 
 /* Line 1455 of yacc.c  */
-#line 326 "parser.y"
+#line 325 "parser.y"
     { fix_incomplete();
                                                  check_statements((yyvsp[(1) - (1)].stmt_list), FALSE);
                                                  check_all_user_types((yyvsp[(1) - (1)].stmt_list));
@@ -2671,28 +2670,28 @@ yyreduce:
   case 3:
 
 /* Line 1455 of yacc.c  */
-#line 339 "parser.y"
+#line 338 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 4:
 
 /* Line 1455 of yacc.c  */
-#line 340 "parser.y"
+#line 339 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_reference((yyvsp[(2) - (2)].type))); ;}
     break;
 
   case 5:
 
 /* Line 1455 of yacc.c  */
-#line 341 "parser.y"
+#line 340 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); ;}
     break;
 
   case 6:
 
 /* Line 1455 of yacc.c  */
-#line 342 "parser.y"
+#line 341 "parser.y"
     { (yyval.stmt_list) = (yyvsp[(1) - (3)].stmt_list);
                                                  reg_type((yyvsp[(2) - (3)].type), (yyvsp[(2) - (3)].type)->name, 0);
                                                ;}
@@ -2701,7 +2700,7 @@ yyreduce:
   case 7:
 
 /* Line 1455 of yacc.c  */
-#line 345 "parser.y"
+#line 344 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type)));
                                                  reg_type((yyvsp[(2) - (2)].type), (yyvsp[(2) - (2)].type)->name, 0);
                                                ;}
@@ -2710,56 +2709,56 @@ yyreduce:
   case 8:
 
 /* Line 1455 of yacc.c  */
-#line 348 "parser.y"
+#line 347 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_module((yyvsp[(2) - (2)].type))); ;}
     break;
 
   case 9:
 
 /* Line 1455 of yacc.c  */
-#line 349 "parser.y"
+#line 348 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_library((yyvsp[(2) - (2)].typelib))); ;}
     break;
 
   case 10:
 
 /* Line 1455 of yacc.c  */
-#line 350 "parser.y"
+#line 349 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); ;}
     break;
 
   case 11:
 
 /* Line 1455 of yacc.c  */
-#line 353 "parser.y"
+#line 352 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 12:
 
 /* Line 1455 of yacc.c  */
-#line 354 "parser.y"
+#line 353 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_reference((yyvsp[(2) - (2)].type))); ;}
     break;
 
   case 13:
 
 /* Line 1455 of yacc.c  */
-#line 355 "parser.y"
+#line 354 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); ;}
     break;
 
   case 14:
 
 /* Line 1455 of yacc.c  */
-#line 356 "parser.y"
+#line 355 "parser.y"
     { (yyval.stmt_list) = (yyvsp[(1) - (3)].stmt_list); reg_type((yyvsp[(2) - (3)].type), (yyvsp[(2) - (3)].type)->name, 0); ;}
     break;
 
   case 15:
 
 /* Line 1455 of yacc.c  */
-#line 357 "parser.y"
+#line 356 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type)));
                                                  reg_type((yyvsp[(2) - (2)].type), (yyvsp[(2) - (2)].type)->name, 0);
                                                ;}
@@ -2768,112 +2767,112 @@ yyreduce:
   case 16:
 
 /* Line 1455 of yacc.c  */
-#line 360 "parser.y"
+#line 359 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_module((yyvsp[(2) - (2)].type))); ;}
     break;
 
   case 17:
 
 /* Line 1455 of yacc.c  */
-#line 361 "parser.y"
+#line 360 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); ;}
     break;
 
   case 18:
 
 /* Line 1455 of yacc.c  */
-#line 362 "parser.y"
+#line 361 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_importlib((yyvsp[(2) - (2)].str))); ;}
     break;
 
   case 19:
 
 /* Line 1455 of yacc.c  */
-#line 363 "parser.y"
+#line 362 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_library((yyvsp[(2) - (2)].typelib))); ;}
     break;
 
   case 20:
 
 /* Line 1455 of yacc.c  */
-#line 366 "parser.y"
+#line 365 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 21:
 
 /* Line 1455 of yacc.c  */
-#line 367 "parser.y"
+#line 366 "parser.y"
     { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); ;}
     break;
 
   case 24:
 
 /* Line 1455 of yacc.c  */
-#line 375 "parser.y"
+#line 374 "parser.y"
     { (yyval.statement) = make_statement_cppquote((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 25:
 
 /* Line 1455 of yacc.c  */
-#line 376 "parser.y"
+#line 375 "parser.y"
     { (yyval.statement) = make_statement_type_decl((yyvsp[(1) - (2)].type)); ;}
     break;
 
   case 26:
 
 /* Line 1455 of yacc.c  */
-#line 377 "parser.y"
+#line 376 "parser.y"
     { (yyval.statement) = make_statement_declaration((yyvsp[(1) - (2)].var)); ;}
     break;
 
   case 27:
 
 /* Line 1455 of yacc.c  */
-#line 378 "parser.y"
+#line 377 "parser.y"
     { (yyval.statement) = make_statement_import((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 28:
 
 /* Line 1455 of yacc.c  */
-#line 379 "parser.y"
+#line 378 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (2)].statement); ;}
     break;
 
   case 32:
 
 /* Line 1455 of yacc.c  */
-#line 386 "parser.y"
+#line 385 "parser.y"
     { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[(1) - (2)].attr_list)); ;}
     break;
 
   case 33:
 
 /* Line 1455 of yacc.c  */
-#line 387 "parser.y"
+#line 386 "parser.y"
     { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[(1) - (2)].attr_list)); ;}
     break;
 
   case 34:
 
 /* Line 1455 of yacc.c  */
-#line 388 "parser.y"
+#line 387 "parser.y"
     { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_union_attrs((yyvsp[(1) - (2)].attr_list)); ;}
     break;
 
   case 35:
 
 /* Line 1455 of yacc.c  */
-#line 391 "parser.y"
+#line 390 "parser.y"
     { (yyval.str) = (yyvsp[(3) - (4)].str); ;}
     break;
 
   case 36:
 
 /* Line 1455 of yacc.c  */
-#line 393 "parser.y"
+#line 392 "parser.y"
     { assert(yychar == YYEMPTY);
                                                  (yyval.import) = xmalloc(sizeof(struct _import_t));
                                                  (yyval.import)->name = (yyvsp[(2) - (3)].str);
@@ -2885,7 +2884,7 @@ yyreduce:
   case 37:
 
 /* Line 1455 of yacc.c  */
-#line 401 "parser.y"
+#line 400 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (3)].import)->name;
                                                  if ((yyvsp[(1) - (3)].import)->import_performed) pop_import();
                                                  free((yyvsp[(1) - (3)].import));
@@ -2895,21 +2894,21 @@ yyreduce:
   case 38:
 
 /* Line 1455 of yacc.c  */
-#line 408 "parser.y"
+#line 407 "parser.y"
     { (yyval.str) = (yyvsp[(3) - (5)].str); if(!parse_only) add_importlib((yyvsp[(3) - (5)].str)); ;}
     break;
 
   case 39:
 
 /* Line 1455 of yacc.c  */
-#line 411 "parser.y"
+#line 410 "parser.y"
     { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
     break;
 
   case 40:
 
 /* Line 1455 of yacc.c  */
-#line 413 "parser.y"
+#line 412 "parser.y"
     { (yyval.typelib) = make_library((yyvsp[(2) - (3)].str), check_library_attrs((yyvsp[(2) - (3)].str), (yyvsp[(1) - (3)].attr_list)));
                                                  if (!parse_only) start_typelib((yyval.typelib));
                                                ;}
@@ -2918,7 +2917,7 @@ yyreduce:
   case 41:
 
 /* Line 1455 of yacc.c  */
-#line 418 "parser.y"
+#line 417 "parser.y"
     { (yyval.typelib) = (yyvsp[(1) - (4)].typelib);
                                                  (yyval.typelib)->stmts = (yyvsp[(2) - (4)].stmt_list);
                                                  if (!parse_only) end_typelib();
@@ -2928,35 +2927,35 @@ yyreduce:
   case 42:
 
 /* Line 1455 of yacc.c  */
-#line 424 "parser.y"
+#line 423 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 44:
 
 /* Line 1455 of yacc.c  */
-#line 428 "parser.y"
+#line 427 "parser.y"
     { check_arg_attrs((yyvsp[(1) - (1)].var)); (yyval.var_list) = append_var( NULL, (yyvsp[(1) - (1)].var) ); ;}
     break;
 
   case 45:
 
 /* Line 1455 of yacc.c  */
-#line 429 "parser.y"
+#line 428 "parser.y"
     { check_arg_attrs((yyvsp[(3) - (3)].var)); (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(3) - (3)].var) ); ;}
     break;
 
   case 47:
 
 /* Line 1455 of yacc.c  */
-#line 433 "parser.y"
+#line 432 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), make_var(strdup("...")) ); ;}
     break;
 
   case 48:
 
 /* Line 1455 of yacc.c  */
-#line 437 "parser.y"
+#line 436 "parser.y"
     { if ((yyvsp[(2) - (3)].declspec)->stgclass != STG_NONE && (yyvsp[(2) - (3)].declspec)->stgclass != STG_REGISTER)
                                                    error_loc("invalid storage class for function parameter\n");
                                                  (yyval.var) = declare_var((yyvsp[(1) - (3)].attr_list), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), TRUE);
@@ -2967,7 +2966,7 @@ yyreduce:
   case 49:
 
 /* Line 1455 of yacc.c  */
-#line 442 "parser.y"
+#line 441 "parser.y"
     { if ((yyvsp[(1) - (2)].declspec)->stgclass != STG_NONE && (yyvsp[(1) - (2)].declspec)->stgclass != STG_REGISTER)
                                                    error_loc("invalid storage class for function parameter\n");
                                                  (yyval.var) = declare_var(NULL, (yyvsp[(1) - (2)].declspec), (yyvsp[(2) - (2)].declarator), TRUE);
@@ -2978,455 +2977,455 @@ yyreduce:
   case 50:
 
 /* Line 1455 of yacc.c  */
-#line 449 "parser.y"
+#line 448 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
     break;
 
   case 51:
 
 /* Line 1455 of yacc.c  */
-#line 450 "parser.y"
+#line 449 "parser.y"
     { (yyval.expr) = make_expr(EXPR_VOID); ;}
     break;
 
   case 52:
 
 /* Line 1455 of yacc.c  */
-#line 453 "parser.y"
+#line 452 "parser.y"
     { (yyval.attr_list) = NULL; ;}
     break;
 
   case 54:
 
 /* Line 1455 of yacc.c  */
-#line 458 "parser.y"
+#line 457 "parser.y"
     { (yyval.attr_list) = (yyvsp[(2) - (3)].attr_list); ;}
     break;
 
   case 55:
 
 /* Line 1455 of yacc.c  */
-#line 461 "parser.y"
+#line 460 "parser.y"
     { (yyval.attr_list) = append_attr( NULL, (yyvsp[(1) - (1)].attr) ); ;}
     break;
 
   case 56:
 
 /* Line 1455 of yacc.c  */
-#line 462 "parser.y"
+#line 461 "parser.y"
     { (yyval.attr_list) = append_attr( (yyvsp[(1) - (3)].attr_list), (yyvsp[(3) - (3)].attr) ); ;}
     break;
 
   case 57:
 
 /* Line 1455 of yacc.c  */
-#line 463 "parser.y"
+#line 462 "parser.y"
     { (yyval.attr_list) = append_attr( (yyvsp[(1) - (4)].attr_list), (yyvsp[(4) - (4)].attr) ); ;}
     break;
 
   case 58:
 
 /* Line 1455 of yacc.c  */
-#line 466 "parser.y"
+#line 465 "parser.y"
     { (yyval.str_list) = append_str( NULL, (yyvsp[(1) - (1)].str) ); ;}
     break;
 
   case 59:
 
 /* Line 1455 of yacc.c  */
-#line 467 "parser.y"
+#line 466 "parser.y"
     { (yyval.str_list) = append_str( (yyvsp[(1) - (3)].str_list), (yyvsp[(3) - (3)].str) ); ;}
     break;
 
   case 60:
 
 /* Line 1455 of yacc.c  */
-#line 470 "parser.y"
+#line 469 "parser.y"
     { (yyval.attr) = NULL; ;}
     break;
 
   case 61:
 
 /* Line 1455 of yacc.c  */
-#line 471 "parser.y"
+#line 470 "parser.y"
     { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); ;}
     break;
 
   case 62:
 
 /* Line 1455 of yacc.c  */
-#line 472 "parser.y"
+#line 471 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 63:
 
 /* Line 1455 of yacc.c  */
-#line 473 "parser.y"
+#line 472 "parser.y"
     { (yyval.attr) = make_attr(ATTR_APPOBJECT); ;}
     break;
 
   case 64:
 
 /* Line 1455 of yacc.c  */
-#line 474 "parser.y"
+#line 473 "parser.y"
     { (yyval.attr) = make_attr(ATTR_ASYNC); ;}
     break;
 
   case 65:
 
 /* Line 1455 of yacc.c  */
-#line 475 "parser.y"
+#line 474 "parser.y"
     { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); ;}
     break;
 
   case 66:
 
 /* Line 1455 of yacc.c  */
-#line 476 "parser.y"
+#line 475 "parser.y"
     { (yyval.attr) = make_attr(ATTR_BINDABLE); ;}
     break;
 
   case 67:
 
 /* Line 1455 of yacc.c  */
-#line 477 "parser.y"
+#line 476 "parser.y"
     { (yyval.attr) = make_attr(ATTR_BROADCAST); ;}
     break;
 
   case 68:
 
 /* Line 1455 of yacc.c  */
-#line 478 "parser.y"
+#line 477 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[(3) - (4)].var)); ;}
     break;
 
   case 69:
 
 /* Line 1455 of yacc.c  */
-#line 479 "parser.y"
+#line 478 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 70:
 
 /* Line 1455 of yacc.c  */
-#line 480 "parser.y"
+#line 479 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); ;}
     break;
 
   case 71:
 
 /* Line 1455 of yacc.c  */
-#line 481 "parser.y"
+#line 480 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ ;}
     break;
 
   case 72:
 
 /* Line 1455 of yacc.c  */
-#line 482 "parser.y"
+#line 481 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ ;}
     break;
 
   case 73:
 
 /* Line 1455 of yacc.c  */
-#line 483 "parser.y"
+#line 482 "parser.y"
     { (yyval.attr) = make_attr(ATTR_CONTROL); ;}
     break;
 
   case 74:
 
 /* Line 1455 of yacc.c  */
-#line 484 "parser.y"
+#line 483 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DEFAULT); ;}
     break;
 
   case 75:
 
 /* Line 1455 of yacc.c  */
-#line 485 "parser.y"
+#line 484 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); ;}
     break;
 
   case 76:
 
 /* Line 1455 of yacc.c  */
-#line 486 "parser.y"
+#line 485 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 77:
 
 /* Line 1455 of yacc.c  */
-#line 487 "parser.y"
+#line 486 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); ;}
     break;
 
   case 78:
 
 /* Line 1455 of yacc.c  */
-#line 488 "parser.y"
+#line 487 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); ;}
     break;
 
   case 79:
 
 /* Line 1455 of yacc.c  */
-#line 489 "parser.y"
+#line 488 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 80:
 
 /* Line 1455 of yacc.c  */
-#line 490 "parser.y"
+#line 489 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DUAL); ;}
     break;
 
   case 81:
 
 /* Line 1455 of yacc.c  */
-#line 491 "parser.y"
+#line 490 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[(3) - (4)].str_list)); ;}
     break;
 
   case 82:
 
 /* Line 1455 of yacc.c  */
-#line 492 "parser.y"
+#line 491 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 83:
 
 /* Line 1455 of yacc.c  */
-#line 493 "parser.y"
+#line 492 "parser.y"
     { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); ;}
     break;
 
   case 84:
 
 /* Line 1455 of yacc.c  */
-#line 494 "parser.y"
+#line 493 "parser.y"
     { (yyval.attr) = make_attr(ATTR_HANDLE); ;}
     break;
 
   case 85:
 
 /* Line 1455 of yacc.c  */
-#line 495 "parser.y"
+#line 494 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 86:
 
 /* Line 1455 of yacc.c  */
-#line 496 "parser.y"
+#line 495 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 87:
 
 /* Line 1455 of yacc.c  */
-#line 497 "parser.y"
+#line 496 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 88:
 
 /* Line 1455 of yacc.c  */
-#line 498 "parser.y"
+#line 497 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 89:
 
 /* Line 1455 of yacc.c  */
-#line 499 "parser.y"
+#line 498 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 90:
 
 /* Line 1455 of yacc.c  */
-#line 500 "parser.y"
+#line 499 "parser.y"
     { (yyval.attr) = make_attr(ATTR_HIDDEN); ;}
     break;
 
   case 91:
 
 /* Line 1455 of yacc.c  */
-#line 501 "parser.y"
+#line 500 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 92:
 
 /* Line 1455 of yacc.c  */
-#line 502 "parser.y"
+#line 501 "parser.y"
     { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); ;}
     break;
 
   case 93:
 
 /* Line 1455 of yacc.c  */
-#line 503 "parser.y"
+#line 502 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 94:
 
 /* Line 1455 of yacc.c  */
-#line 504 "parser.y"
+#line 503 "parser.y"
     { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); ;}
     break;
 
   case 95:
 
 /* Line 1455 of yacc.c  */
-#line 505 "parser.y"
+#line 504 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[(4) - (5)].str)); ;}
     break;
 
   case 96:
 
 /* Line 1455 of yacc.c  */
-#line 506 "parser.y"
+#line 505 "parser.y"
     { (yyval.attr) = make_attr(ATTR_IN); ;}
     break;
 
   case 97:
 
 /* Line 1455 of yacc.c  */
-#line 507 "parser.y"
+#line 506 "parser.y"
     { (yyval.attr) = make_attr(ATTR_INPUTSYNC); ;}
     break;
 
   case 98:
 
 /* Line 1455 of yacc.c  */
-#line 508 "parser.y"
+#line 507 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 99:
 
 /* Line 1455 of yacc.c  */
-#line 509 "parser.y"
+#line 508 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 100:
 
 /* Line 1455 of yacc.c  */
-#line 510 "parser.y"
+#line 509 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PARAMLCID); ;}
     break;
 
   case 101:
 
 /* Line 1455 of yacc.c  */
-#line 511 "parser.y"
+#line 510 "parser.y"
     { (yyval.attr) = make_attr(ATTR_LOCAL); ;}
     break;
 
   case 102:
 
 /* Line 1455 of yacc.c  */
-#line 512 "parser.y"
+#line 511 "parser.y"
     { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;}
     break;
 
   case 103:
 
 /* Line 1455 of yacc.c  */
-#line 513 "parser.y"
+#line 512 "parser.y"
     { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;}
     break;
 
   case 104:
 
 /* Line 1455 of yacc.c  */
-#line 514 "parser.y"
+#line 513 "parser.y"
     { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;}
     break;
 
   case 105:
 
 /* Line 1455 of yacc.c  */
-#line 515 "parser.y"
+#line 514 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OBJECT); ;}
     break;
 
   case 106:
 
 /* Line 1455 of yacc.c  */
-#line 516 "parser.y"
+#line 515 "parser.y"
     { (yyval.attr) = make_attr(ATTR_ODL); ;}
     break;
 
   case 107:
 
 /* Line 1455 of yacc.c  */
-#line 517 "parser.y"
+#line 516 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;}
     break;
 
   case 108:
 
 /* Line 1455 of yacc.c  */
-#line 518 "parser.y"
+#line 517 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;}
     break;
 
   case 109:
 
 /* Line 1455 of yacc.c  */
-#line 519 "parser.y"
+#line 518 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OUT); ;}
     break;
 
   case 110:
 
 /* Line 1455 of yacc.c  */
-#line 520 "parser.y"
+#line 519 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[(3) - (4)].num)); ;}
     break;
 
   case 111:
 
 /* Line 1455 of yacc.c  */
-#line 521 "parser.y"
+#line 520 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPGET); ;}
     break;
 
   case 112:
 
 /* Line 1455 of yacc.c  */
-#line 522 "parser.y"
+#line 521 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPPUT); ;}
     break;
 
   case 113:
 
 /* Line 1455 of yacc.c  */
-#line 523 "parser.y"
+#line 522 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPPUTREF); ;}
     break;
 
   case 114:
 
 /* Line 1455 of yacc.c  */
-#line 524 "parser.y"
+#line 523 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PUBLIC); ;}
     break;
 
   case 115:
 
 /* Line 1455 of yacc.c  */
-#line 526 "parser.y"
+#line 525 "parser.y"
     { expr_list_t *list = append_expr( NULL, (yyvsp[(3) - (6)].expr) );
                                                  list = append_expr( list, (yyvsp[(5) - (6)].expr) );
                                                  (yyval.attr) = make_attrp(ATTR_RANGE, list); ;}
@@ -3435,126 +3434,126 @@ yyreduce:
   case 116:
 
 /* Line 1455 of yacc.c  */
-#line 529 "parser.y"
+#line 528 "parser.y"
     { (yyval.attr) = make_attr(ATTR_READONLY); ;}
     break;
 
   case 117:
 
 /* Line 1455 of yacc.c  */
-#line 530 "parser.y"
+#line 529 "parser.y"
     { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); ;}
     break;
 
   case 118:
 
 /* Line 1455 of yacc.c  */
-#line 531 "parser.y"
+#line 530 "parser.y"
     { (yyval.attr) = make_attr(ATTR_RESTRICTED); ;}
     break;
 
   case 119:
 
 /* Line 1455 of yacc.c  */
-#line 532 "parser.y"
+#line 531 "parser.y"
     { (yyval.attr) = make_attr(ATTR_RETVAL); ;}
     break;
 
   case 120:
 
 /* Line 1455 of yacc.c  */
-#line 533 "parser.y"
+#line 532 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 121:
 
 /* Line 1455 of yacc.c  */
-#line 534 "parser.y"
+#line 533 "parser.y"
     { (yyval.attr) = make_attr(ATTR_SOURCE); ;}
     break;
 
   case 122:
 
 /* Line 1455 of yacc.c  */
-#line 535 "parser.y"
+#line 534 "parser.y"
     { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); ;}
     break;
 
   case 123:
 
 /* Line 1455 of yacc.c  */
-#line 536 "parser.y"
+#line 535 "parser.y"
     { (yyval.attr) = make_attr(ATTR_STRING); ;}
     break;
 
   case 124:
 
 /* Line 1455 of yacc.c  */
-#line 537 "parser.y"
+#line 536 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 125:
 
 /* Line 1455 of yacc.c  */
-#line 538 "parser.y"
+#line 537 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 126:
 
 /* Line 1455 of yacc.c  */
-#line 539 "parser.y"
+#line 538 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 127:
 
 /* Line 1455 of yacc.c  */
-#line 540 "parser.y"
+#line 539 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[(3) - (4)].uuid)); ;}
     break;
 
   case 128:
 
 /* Line 1455 of yacc.c  */
-#line 541 "parser.y"
+#line 540 "parser.y"
     { (yyval.attr) = make_attr(ATTR_V1ENUM); ;}
     break;
 
   case 129:
 
 /* Line 1455 of yacc.c  */
-#line 542 "parser.y"
+#line 541 "parser.y"
     { (yyval.attr) = make_attr(ATTR_VARARG); ;}
     break;
 
   case 130:
 
 /* Line 1455 of yacc.c  */
-#line 543 "parser.y"
+#line 542 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[(3) - (4)].num)); ;}
     break;
 
   case 131:
 
 /* Line 1455 of yacc.c  */
-#line 544 "parser.y"
+#line 543 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 132:
 
 /* Line 1455 of yacc.c  */
-#line 545 "parser.y"
+#line 544 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 134:
 
 /* Line 1455 of yacc.c  */
-#line 550 "parser.y"
+#line 549 "parser.y"
     { if (!is_valid_uuid((yyvsp[(1) - (1)].str)))
                                                    error_loc("invalid UUID: %s\n", (yyvsp[(1) - (1)].str));
                                                  (yyval.uuid) = parse_uuid((yyvsp[(1) - (1)].str)); ;}
@@ -3563,49 +3562,49 @@ yyreduce:
   case 135:
 
 /* Line 1455 of yacc.c  */
-#line 555 "parser.y"
+#line 554 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 136:
 
 /* Line 1455 of yacc.c  */
-#line 556 "parser.y"
+#line 555 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 137:
 
 /* Line 1455 of yacc.c  */
-#line 557 "parser.y"
+#line 556 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 138:
 
 /* Line 1455 of yacc.c  */
-#line 558 "parser.y"
+#line 557 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 139:
 
 /* Line 1455 of yacc.c  */
-#line 561 "parser.y"
+#line 560 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 140:
 
 /* Line 1455 of yacc.c  */
-#line 562 "parser.y"
+#line 561 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;}
     break;
 
   case 141:
 
 /* Line 1455 of yacc.c  */
-#line 565 "parser.y"
+#line 564 "parser.y"
     { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, (yyvsp[(2) - (4)].expr) ));
                                                  (yyval.var) = (yyvsp[(4) - (4)].var); if (!(yyval.var)) (yyval.var) = make_var(NULL);
                                                  (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a );
@@ -3615,7 +3614,7 @@ yyreduce:
   case 142:
 
 /* Line 1455 of yacc.c  */
-#line 569 "parser.y"
+#line 568 "parser.y"
     { attr_t *a = make_attr(ATTR_DEFAULT);
                                                  (yyval.var) = (yyvsp[(3) - (3)].var); if (!(yyval.var)) (yyval.var) = make_var(NULL);
                                                  (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a );
@@ -3625,21 +3624,21 @@ yyreduce:
   case 143:
 
 /* Line 1455 of yacc.c  */
-#line 575 "parser.y"
+#line 574 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 144:
 
 /* Line 1455 of yacc.c  */
-#line 576 "parser.y"
+#line 575 "parser.y"
     { (yyval.var_list) = (yyvsp[(1) - (2)].var_list); ;}
     break;
 
   case 146:
 
 /* Line 1455 of yacc.c  */
-#line 580 "parser.y"
+#line 579 "parser.y"
     { if (!(yyvsp[(1) - (1)].var)->eval)
                                                    (yyvsp[(1) - (1)].var)->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
                                                   (yyval.var_list) = append_var( NULL, (yyvsp[(1) - (1)].var) );
@@ -3649,7 +3648,7 @@ yyreduce:
   case 147:
 
 /* Line 1455 of yacc.c  */
-#line 584 "parser.y"
+#line 583 "parser.y"
     { if (!(yyvsp[(3) - (3)].var)->eval)
                                                   {
                                                     var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry );
@@ -3662,7 +3661,7 @@ yyreduce:
   case 148:
 
 /* Line 1455 of yacc.c  */
-#line 593 "parser.y"
+#line 592 "parser.y"
     { (yyval.var) = reg_const((yyvsp[(1) - (3)].var));
                                                  (yyval.var)->eval = (yyvsp[(3) - (3)].expr);
                                                   (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0);
@@ -3672,7 +3671,7 @@ yyreduce:
   case 149:
 
 /* Line 1455 of yacc.c  */
-#line 597 "parser.y"
+#line 596 "parser.y"
     { (yyval.var) = reg_const((yyvsp[(1) - (1)].var));
                                                   (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0);
                                                ;}
@@ -3681,336 +3680,336 @@ yyreduce:
   case 150:
 
 /* Line 1455 of yacc.c  */
-#line 602 "parser.y"
+#line 601 "parser.y"
     { (yyval.type) = type_new_enum((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;}
     break;
 
   case 151:
 
 /* Line 1455 of yacc.c  */
-#line 605 "parser.y"
+#line 604 "parser.y"
     { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
     break;
 
   case 152:
 
 /* Line 1455 of yacc.c  */
-#line 606 "parser.y"
+#line 605 "parser.y"
     { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;}
     break;
 
   case 153:
 
 /* Line 1455 of yacc.c  */
-#line 619 "parser.y"
+#line 618 "parser.y"
     { (yyval.expr) = make_expr(EXPR_VOID); ;}
     break;
 
   case 155:
 
 /* Line 1455 of yacc.c  */
-#line 623 "parser.y"
+#line 622 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 156:
 
 /* Line 1455 of yacc.c  */
-#line 624 "parser.y"
+#line 623 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 157:
 
 /* Line 1455 of yacc.c  */
-#line 625 "parser.y"
+#line 624 "parser.y"
     { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[(1) - (1)].dbl)); ;}
     break;
 
   case 158:
 
 /* Line 1455 of yacc.c  */
-#line 626 "parser.y"
+#line 625 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); ;}
     break;
 
   case 159:
 
 /* Line 1455 of yacc.c  */
-#line 627 "parser.y"
+#line 626 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_NUM, 0); ;}
     break;
 
   case 160:
 
 /* Line 1455 of yacc.c  */
-#line 628 "parser.y"
+#line 627 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); ;}
     break;
 
   case 161:
 
 /* Line 1455 of yacc.c  */
-#line 629 "parser.y"
+#line 628 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 162:
 
 /* Line 1455 of yacc.c  */
-#line 630 "parser.y"
+#line 629 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 163:
 
 /* Line 1455 of yacc.c  */
-#line 631 "parser.y"
+#line 630 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 164:
 
 /* Line 1455 of yacc.c  */
-#line 632 "parser.y"
+#line 631 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 165:
 
 /* Line 1455 of yacc.c  */
-#line 633 "parser.y"
+#line 632 "parser.y"
     { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); ;}
     break;
 
   case 166:
 
 /* Line 1455 of yacc.c  */
-#line 634 "parser.y"
+#line 633 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 167:
 
 /* Line 1455 of yacc.c  */
-#line 635 "parser.y"
+#line 634 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 168:
 
 /* Line 1455 of yacc.c  */
-#line 636 "parser.y"
+#line 635 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 169:
 
 /* Line 1455 of yacc.c  */
-#line 637 "parser.y"
+#line 636 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 170:
 
 /* Line 1455 of yacc.c  */
-#line 638 "parser.y"
+#line 637 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 171:
 
 /* Line 1455 of yacc.c  */
-#line 639 "parser.y"
+#line 638 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 172:
 
 /* Line 1455 of yacc.c  */
-#line 640 "parser.y"
+#line 639 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 173:
 
 /* Line 1455 of yacc.c  */
-#line 641 "parser.y"
+#line 640 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 174:
 
 /* Line 1455 of yacc.c  */
-#line 642 "parser.y"
+#line 641 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 175:
 
 /* Line 1455 of yacc.c  */
-#line 643 "parser.y"
+#line 642 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 176:
 
 /* Line 1455 of yacc.c  */
-#line 644 "parser.y"
+#line 643 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 177:
 
 /* Line 1455 of yacc.c  */
-#line 645 "parser.y"
+#line 644 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 178:
 
 /* Line 1455 of yacc.c  */
-#line 646 "parser.y"
+#line 645 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 179:
 
 /* Line 1455 of yacc.c  */
-#line 647 "parser.y"
+#line 646 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 180:
 
 /* Line 1455 of yacc.c  */
-#line 648 "parser.y"
+#line 647 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 181:
 
 /* Line 1455 of yacc.c  */
-#line 649 "parser.y"
+#line 648 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 182:
 
 /* Line 1455 of yacc.c  */
-#line 650 "parser.y"
+#line 649 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 183:
 
 /* Line 1455 of yacc.c  */
-#line 651 "parser.y"
+#line 650 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 184:
 
 /* Line 1455 of yacc.c  */
-#line 652 "parser.y"
+#line 651 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 185:
 
 /* Line 1455 of yacc.c  */
-#line 653 "parser.y"
+#line 652 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 186:
 
 /* Line 1455 of yacc.c  */
-#line 654 "parser.y"
+#line 653 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 187:
 
 /* Line 1455 of yacc.c  */
-#line 655 "parser.y"
+#line 654 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 188:
 
 /* Line 1455 of yacc.c  */
-#line 656 "parser.y"
+#line 655 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 189:
 
 /* Line 1455 of yacc.c  */
-#line 657 "parser.y"
+#line 656 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 190:
 
 /* Line 1455 of yacc.c  */
-#line 658 "parser.y"
+#line 657 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[(1) - (3)].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); ;}
     break;
 
   case 191:
 
 /* Line 1455 of yacc.c  */
-#line 659 "parser.y"
+#line 658 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[(1) - (3)].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); ;}
     break;
 
   case 192:
 
 /* Line 1455 of yacc.c  */
-#line 661 "parser.y"
+#line 660 "parser.y"
     { (yyval.expr) = make_exprt(EXPR_CAST, declare_var(NULL, (yyvsp[(2) - (5)].declspec), (yyvsp[(3) - (5)].declarator), 0), (yyvsp[(5) - (5)].expr)); free((yyvsp[(2) - (5)].declspec)); free((yyvsp[(3) - (5)].declarator)); ;}
     break;
 
   case 193:
 
 /* Line 1455 of yacc.c  */
-#line 663 "parser.y"
+#line 662 "parser.y"
     { (yyval.expr) = make_exprt(EXPR_SIZEOF, declare_var(NULL, (yyvsp[(3) - (5)].declspec), (yyvsp[(4) - (5)].declarator), 0), NULL); free((yyvsp[(3) - (5)].declspec)); free((yyvsp[(4) - (5)].declarator)); ;}
     break;
 
   case 194:
 
 /* Line 1455 of yacc.c  */
-#line 664 "parser.y"
+#line 663 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 195:
 
 /* Line 1455 of yacc.c  */
-#line 665 "parser.y"
+#line 664 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
     break;
 
   case 196:
 
 /* Line 1455 of yacc.c  */
-#line 668 "parser.y"
+#line 667 "parser.y"
     { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
     break;
 
   case 197:
 
 /* Line 1455 of yacc.c  */
-#line 669 "parser.y"
+#line 668 "parser.y"
     { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;}
     break;
 
   case 198:
 
 /* Line 1455 of yacc.c  */
-#line 672 "parser.y"
+#line 671 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);
                                                  if (!(yyval.expr)->is_const)
                                                      error_loc("expression is not an integer constant\n");
@@ -4020,7 +4019,7 @@ yyreduce:
   case 199:
 
 /* Line 1455 of yacc.c  */
-#line 678 "parser.y"
+#line 677 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);
                                                  if (!(yyval.expr)->is_const && (yyval.expr)->type != EXPR_STRLIT && (yyval.expr)->type != EXPR_WSTRLIT)
                                                      error_loc("expression is not constant\n");
@@ -4030,21 +4029,21 @@ yyreduce:
   case 200:
 
 /* Line 1455 of yacc.c  */
-#line 684 "parser.y"
+#line 683 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 201:
 
 /* Line 1455 of yacc.c  */
-#line 685 "parser.y"
+#line 684 "parser.y"
     { (yyval.var_list) = append_var_list((yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var_list)); ;}
     break;
 
   case 202:
 
 /* Line 1455 of yacc.c  */
-#line 689 "parser.y"
+#line 688 "parser.y"
     { const char *first = LIST_ENTRY(list_head((yyvsp[(3) - (4)].declarator_list)), declarator_t, entry)->var->name;
                                                  check_field_attrs(first, (yyvsp[(1) - (4)].attr_list));
                                                  (yyval.var_list) = set_var_types((yyvsp[(1) - (4)].attr_list), (yyvsp[(2) - (4)].declspec), (yyvsp[(3) - (4)].declarator_list));
@@ -4054,7 +4053,7 @@ yyreduce:
   case 203:
 
 /* Line 1455 of yacc.c  */
-#line 693 "parser.y"
+#line 692 "parser.y"
     { var_t *v = make_var(NULL);
                                                  v->type = (yyvsp[(2) - (3)].type); v->attrs = (yyvsp[(1) - (3)].attr_list);
                                                  (yyval.var_list) = append_var(NULL, v);
@@ -4064,49 +4063,49 @@ yyreduce:
   case 204:
 
 /* Line 1455 of yacc.c  */
-#line 700 "parser.y"
+#line 699 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (2)].var); ;}
     break;
 
   case 205:
 
 /* Line 1455 of yacc.c  */
-#line 701 "parser.y"
+#line 700 "parser.y"
     { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[(1) - (2)].attr_list); ;}
     break;
 
   case 206:
 
 /* Line 1455 of yacc.c  */
-#line 704 "parser.y"
+#line 703 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 207:
 
 /* Line 1455 of yacc.c  */
-#line 705 "parser.y"
+#line 704 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;}
     break;
 
   case 208:
 
 /* Line 1455 of yacc.c  */
-#line 709 "parser.y"
+#line 708 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (2)].var); ;}
     break;
 
   case 209:
 
 /* Line 1455 of yacc.c  */
-#line 710 "parser.y"
+#line 709 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
   case 210:
 
 /* Line 1455 of yacc.c  */
-#line 713 "parser.y"
+#line 712 "parser.y"
     { (yyval.var) = declare_var(check_field_attrs((yyvsp[(3) - (3)].declarator)->var->name, (yyvsp[(1) - (3)].attr_list)),
                                                                (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE);
                                                  free((yyvsp[(3) - (3)].declarator));
@@ -4116,7 +4115,7 @@ yyreduce:
   case 211:
 
 /* Line 1455 of yacc.c  */
-#line 719 "parser.y"
+#line 718 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (1)].var);
                                                  if (type_get_type((yyval.var)->type) != TYPE_FUNCTION)
                                                    error_loc("only methods may be declared inside the methods section of a dispinterface\n");
@@ -4127,7 +4126,7 @@ yyreduce:
   case 212:
 
 /* Line 1455 of yacc.c  */
-#line 728 "parser.y"
+#line 727 "parser.y"
     { (yyval.var) = declare_var((yyvsp[(1) - (3)].attr_list), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE);
                                                  free((yyvsp[(3) - (3)].declarator));
                                                ;}
@@ -4136,7 +4135,7 @@ yyreduce:
   case 213:
 
 /* Line 1455 of yacc.c  */
-#line 731 "parser.y"
+#line 730 "parser.y"
     { (yyval.var) = declare_var(NULL, (yyvsp[(1) - (2)].declspec), (yyvsp[(2) - (2)].declarator), FALSE);
                                                  free((yyvsp[(2) - (2)].declarator));
                                                ;}
@@ -4145,182 +4144,182 @@ yyreduce:
   case 214:
 
 /* Line 1455 of yacc.c  */
-#line 736 "parser.y"
+#line 735 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
   case 216:
 
 /* Line 1455 of yacc.c  */
-#line 740 "parser.y"
+#line 739 "parser.y"
     { (yyval.str) = NULL; ;}
     break;
 
   case 217:
 
 /* Line 1455 of yacc.c  */
-#line 741 "parser.y"
+#line 740 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 218:
 
 /* Line 1455 of yacc.c  */
-#line 742 "parser.y"
+#line 741 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 219:
 
 /* Line 1455 of yacc.c  */
-#line 745 "parser.y"
+#line 744 "parser.y"
     { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 220:
 
 /* Line 1455 of yacc.c  */
-#line 747 "parser.y"
+#line 746 "parser.y"
     { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 221:
 
 /* Line 1455 of yacc.c  */
-#line 750 "parser.y"
+#line 749 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 222:
 
 /* Line 1455 of yacc.c  */
-#line 751 "parser.y"
+#line 750 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 224:
 
 /* Line 1455 of yacc.c  */
-#line 753 "parser.y"
+#line 752 "parser.y"
     { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[(2) - (2)].type)), -1); ;}
     break;
 
   case 225:
 
 /* Line 1455 of yacc.c  */
-#line 754 "parser.y"
+#line 753 "parser.y"
     { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[(2) - (2)].type)), 1); ;}
     break;
 
   case 226:
 
 /* Line 1455 of yacc.c  */
-#line 755 "parser.y"
+#line 754 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); ;}
     break;
 
   case 227:
 
 /* Line 1455 of yacc.c  */
-#line 756 "parser.y"
+#line 755 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 228:
 
 /* Line 1455 of yacc.c  */
-#line 757 "parser.y"
+#line 756 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 229:
 
 /* Line 1455 of yacc.c  */
-#line 758 "parser.y"
+#line 757 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 230:
 
 /* Line 1455 of yacc.c  */
-#line 759 "parser.y"
+#line 758 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 231:
 
 /* Line 1455 of yacc.c  */
-#line 760 "parser.y"
+#line 759 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 234:
 
 /* Line 1455 of yacc.c  */
-#line 767 "parser.y"
+#line 766 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); ;}
     break;
 
   case 235:
 
 /* Line 1455 of yacc.c  */
-#line 768 "parser.y"
+#line 767 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); ;}
     break;
 
   case 236:
 
 /* Line 1455 of yacc.c  */
-#line 769 "parser.y"
+#line 768 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); ;}
     break;
 
   case 237:
 
 /* Line 1455 of yacc.c  */
-#line 770 "parser.y"
+#line 769 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); ;}
     break;
 
   case 238:
 
 /* Line 1455 of yacc.c  */
-#line 771 "parser.y"
+#line 770 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); ;}
     break;
 
   case 239:
 
 /* Line 1455 of yacc.c  */
-#line 772 "parser.y"
+#line 771 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); ;}
     break;
 
   case 240:
 
 /* Line 1455 of yacc.c  */
-#line 773 "parser.y"
+#line 772 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); ;}
     break;
 
   case 241:
 
 /* Line 1455 of yacc.c  */
-#line 774 "parser.y"
+#line 773 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); ;}
     break;
 
   case 242:
 
 /* Line 1455 of yacc.c  */
-#line 777 "parser.y"
+#line 776 "parser.y"
     { (yyval.type) = type_new_coclass((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 243:
 
 /* Line 1455 of yacc.c  */
-#line 778 "parser.y"
+#line 777 "parser.y"
     { (yyval.type) = find_type((yyvsp[(2) - (2)].str), 0);
                                                  if (type_get_type_detect_alias((yyval.type)) != TYPE_COCLASS)
                                                    error_loc("%s was not declared a coclass at %s:%d\n",
@@ -4332,7 +4331,7 @@ yyreduce:
   case 244:
 
 /* Line 1455 of yacc.c  */
-#line 786 "parser.y"
+#line 785 "parser.y"
     { (yyval.type) = (yyvsp[(2) - (2)].type);
                                                  check_def((yyval.type));
                                                  (yyval.type)->attrs = check_coclass_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list));
@@ -4342,51 +4341,50 @@ yyreduce:
   case 245:
 
 /* Line 1455 of yacc.c  */
-#line 793 "parser.y"
+#line 792 "parser.y"
     { (yyval.type) = type_coclass_define((yyvsp[(1) - (5)].type), (yyvsp[(3) - (5)].ifref_list)); ;}
     break;
 
   case 246:
 
 /* Line 1455 of yacc.c  */
-#line 796 "parser.y"
+#line 795 "parser.y"
     { (yyval.ifref_list) = NULL; ;}
     break;
 
   case 247:
 
 /* Line 1455 of yacc.c  */
-#line 797 "parser.y"
+#line 796 "parser.y"
     { (yyval.ifref_list) = append_ifref( (yyvsp[(1) - (2)].ifref_list), (yyvsp[(2) - (2)].ifref) ); ;}
     break;
 
   case 248:
 
 /* Line 1455 of yacc.c  */
-#line 801 "parser.y"
+#line 800 "parser.y"
     { (yyval.ifref) = make_ifref((yyvsp[(2) - (2)].type)); (yyval.ifref)->attrs = (yyvsp[(1) - (2)].attr_list); ;}
     break;
 
   case 249:
 
 /* Line 1455 of yacc.c  */
-#line 804 "parser.y"
+#line 803 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 250:
 
 /* Line 1455 of yacc.c  */
-#line 805 "parser.y"
+#line 804 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 251:
 
 /* Line 1455 of yacc.c  */
-#line 808 "parser.y"
+#line 807 "parser.y"
     { attr_t *attrs;
-                                                 is_object_interface = TRUE;
                                                  (yyval.type) = (yyvsp[(2) - (2)].type);
                                                  check_def((yyval.type));
                                                  attrs = make_attr(ATTR_DISPINTERFACE);
@@ -4398,35 +4396,35 @@ yyreduce:
   case 252:
 
 /* Line 1455 of yacc.c  */
-#line 818 "parser.y"
+#line 816 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 253:
 
 /* Line 1455 of yacc.c  */
-#line 819 "parser.y"
+#line 817 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); ;}
     break;
 
   case 254:
 
 /* Line 1455 of yacc.c  */
-#line 822 "parser.y"
+#line 820 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 255:
 
 /* Line 1455 of yacc.c  */
-#line 823 "parser.y"
+#line 821 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); ;}
     break;
 
   case 256:
 
 /* Line 1455 of yacc.c  */
-#line 829 "parser.y"
+#line 827 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                  type_dispinterface_define((yyval.type), (yyvsp[(3) - (5)].var_list), (yyvsp[(4) - (5)].var_list));
                                                ;}
@@ -4435,7 +4433,7 @@ yyreduce:
   case 257:
 
 /* Line 1455 of yacc.c  */
-#line 833 "parser.y"
+#line 831 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                  type_dispinterface_define_from_iface((yyval.type), (yyvsp[(3) - (5)].type));
                                                ;}
@@ -4444,42 +4442,41 @@ yyreduce:
   case 258:
 
 /* Line 1455 of yacc.c  */
-#line 838 "parser.y"
+#line 836 "parser.y"
     { (yyval.type) = NULL; ;}
     break;
 
   case 259:
 
 /* Line 1455 of yacc.c  */
-#line 839 "parser.y"
-    { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); is_object_interface = 1; ;}
+#line 837 "parser.y"
+    { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 260:
 
 /* Line 1455 of yacc.c  */
-#line 842 "parser.y"
+#line 840 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 261:
 
 /* Line 1455 of yacc.c  */
-#line 843 "parser.y"
+#line 841 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 262:
 
 /* Line 1455 of yacc.c  */
-#line 846 "parser.y"
+#line 844 "parser.y"
     { (yyval.ifinfo).interface = (yyvsp[(2) - (2)].type);
                                                  (yyval.ifinfo).old_pointer_default = pointer_default;
                                                  if (is_attr((yyvsp[(1) - (2)].attr_list), ATTR_POINTERDEFAULT))
                                                    pointer_default = get_attrv((yyvsp[(1) - (2)].attr_list), ATTR_POINTERDEFAULT);
                                                  check_def((yyvsp[(2) - (2)].type));
                                                  (yyvsp[(2) - (2)].type)->attrs = check_iface_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list));
-                                                 is_object_interface = is_object((yyvsp[(2) - (2)].type));
                                                  (yyvsp[(2) - (2)].type)->defined = TRUE;
                                                ;}
     break;
@@ -4487,7 +4484,7 @@ yyreduce:
   case 263:
 
 /* Line 1455 of yacc.c  */
-#line 858 "parser.y"
+#line 855 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (6)].ifinfo).interface;
                                                  type_interface_define((yyval.type), (yyvsp[(2) - (6)].type), (yyvsp[(4) - (6)].stmt_list));
                                                  pointer_default = (yyvsp[(1) - (6)].ifinfo).old_pointer_default;
@@ -4497,7 +4494,7 @@ yyreduce:
   case 264:
 
 /* Line 1455 of yacc.c  */
-#line 866 "parser.y"
+#line 863 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (8)].ifinfo).interface;
                                                  type_interface_define((yyval.type), find_type_or_error2((yyvsp[(3) - (8)].str), 0), (yyvsp[(6) - (8)].stmt_list));
                                                  pointer_default = (yyvsp[(1) - (8)].ifinfo).old_pointer_default;
@@ -4507,42 +4504,42 @@ yyreduce:
   case 265:
 
 /* Line 1455 of yacc.c  */
-#line 870 "parser.y"
+#line 867 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 266:
 
 /* Line 1455 of yacc.c  */
-#line 874 "parser.y"
+#line 871 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 267:
 
 /* Line 1455 of yacc.c  */
-#line 875 "parser.y"
+#line 872 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 268:
 
 /* Line 1455 of yacc.c  */
-#line 878 "parser.y"
+#line 875 "parser.y"
     { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 269:
 
 /* Line 1455 of yacc.c  */
-#line 879 "parser.y"
+#line 876 "parser.y"
     { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 270:
 
 /* Line 1455 of yacc.c  */
-#line 882 "parser.y"
+#line 879 "parser.y"
     { (yyval.type) = (yyvsp[(2) - (2)].type);
                                                  (yyval.type)->attrs = check_module_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list));
                                                ;}
@@ -4551,7 +4548,7 @@ yyreduce:
   case 271:
 
 /* Line 1455 of yacc.c  */
-#line 888 "parser.y"
+#line 885 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                   type_module_define((yyval.type), (yyvsp[(3) - (5)].stmt_list));
                                                ;}
@@ -4560,133 +4557,134 @@ yyreduce:
   case 272:
 
 /* Line 1455 of yacc.c  */
-#line 894 "parser.y"
+#line 891 "parser.y"
     { (yyval.stgclass) = STG_EXTERN; ;}
     break;
 
   case 273:
 
 /* Line 1455 of yacc.c  */
-#line 895 "parser.y"
+#line 892 "parser.y"
     { (yyval.stgclass) = STG_STATIC; ;}
     break;
 
   case 274:
 
 /* Line 1455 of yacc.c  */
-#line 896 "parser.y"
+#line 893 "parser.y"
     { (yyval.stgclass) = STG_REGISTER; ;}
     break;
 
   case 275:
 
 /* Line 1455 of yacc.c  */
-#line 900 "parser.y"
+#line 897 "parser.y"
     { (yyval.attr) = make_attr(ATTR_INLINE); ;}
     break;
 
   case 276:
 
 /* Line 1455 of yacc.c  */
-#line 904 "parser.y"
+#line 901 "parser.y"
     { (yyval.attr) = make_attr(ATTR_CONST); ;}
     break;
 
   case 277:
 
 /* Line 1455 of yacc.c  */
-#line 907 "parser.y"
+#line 904 "parser.y"
     { (yyval.attr_list) = NULL; ;}
     break;
 
   case 278:
 
 /* Line 1455 of yacc.c  */
-#line 908 "parser.y"
+#line 905 "parser.y"
     { (yyval.attr_list) = append_attr((yyvsp[(1) - (2)].attr_list), (yyvsp[(2) - (2)].attr)); ;}
     break;
 
   case 279:
 
 /* Line 1455 of yacc.c  */
-#line 911 "parser.y"
+#line 908 "parser.y"
     { (yyval.declspec) = make_decl_spec((yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].declspec), NULL, NULL, STG_NONE); ;}
     break;
 
   case 280:
 
 /* Line 1455 of yacc.c  */
-#line 913 "parser.y"
+#line 910 "parser.y"
     { (yyval.declspec) = make_decl_spec((yyvsp[(2) - (3)].type), (yyvsp[(1) - (3)].declspec), (yyvsp[(3) - (3)].declspec), NULL, STG_NONE); ;}
     break;
 
   case 281:
 
 /* Line 1455 of yacc.c  */
-#line 916 "parser.y"
+#line 913 "parser.y"
     { (yyval.declspec) = NULL; ;}
     break;
 
   case 283:
 
 /* Line 1455 of yacc.c  */
-#line 921 "parser.y"
+#line 918 "parser.y"
     { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); ;}
     break;
 
   case 284:
 
 /* Line 1455 of yacc.c  */
-#line 922 "parser.y"
+#line 919 "parser.y"
     { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); ;}
     break;
 
   case 285:
 
 /* Line 1455 of yacc.c  */
-#line 923 "parser.y"
+#line 920 "parser.y"
     { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, NULL, (yyvsp[(1) - (2)].stgclass)); ;}
     break;
 
   case 286:
 
 /* Line 1455 of yacc.c  */
-#line 928 "parser.y"
+#line 925 "parser.y"
     { (yyval.declarator) = (yyvsp[(3) - (3)].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[(2) - (3)].attr_list))); ;}
     break;
 
   case 287:
 
 /* Line 1455 of yacc.c  */
-#line 929 "parser.y"
-    { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;}
+#line 926 "parser.y"
+    { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str)));
+                                                          else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;}
     break;
 
   case 289:
 
 /* Line 1455 of yacc.c  */
-#line 934 "parser.y"
+#line 932 "parser.y"
     { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); ;}
     break;
 
   case 290:
 
 /* Line 1455 of yacc.c  */
-#line 935 "parser.y"
+#line 933 "parser.y"
     { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;}
     break;
 
   case 291:
 
 /* Line 1455 of yacc.c  */
-#line 936 "parser.y"
+#line 934 "parser.y"
     { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 292:
 
 /* Line 1455 of yacc.c  */
-#line 937 "parser.y"
+#line 935 "parser.y"
     { (yyval.declarator) = (yyvsp[(1) - (4)].declarator);
                                                  (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[(3) - (4)].var_list)));
                                                  (yyval.declarator)->type = NULL;
@@ -4696,29 +4694,31 @@ yyreduce:
   case 293:
 
 /* Line 1455 of yacc.c  */
-#line 946 "parser.y"
+#line 944 "parser.y"
     { (yyval.declarator) = (yyvsp[(3) - (3)].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[(2) - (3)].attr_list))); ;}
     break;
 
   case 294:
 
 /* Line 1455 of yacc.c  */
-#line 947 "parser.y"
-    { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;}
+#line 945 "parser.y"
+    { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str)));
+                                                          else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;}
     break;
 
   case 296:
 
 /* Line 1455 of yacc.c  */
-#line 954 "parser.y"
+#line 953 "parser.y"
     { (yyval.declarator) = (yyvsp[(3) - (3)].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[(2) - (3)].attr_list))); ;}
     break;
 
   case 297:
 
 /* Line 1455 of yacc.c  */
-#line 955 "parser.y"
-    { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;}
+#line 954 "parser.y"
+    { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str)));
+                                                          else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;}
     break;
 
   case 298:
@@ -5056,7 +5056,7 @@ yyreduce:
 
 
 /* Line 1455 of yacc.c  */
-#line 5052 "parser.tab.c"
+#line 5060 "parser.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -5759,12 +5759,6 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
      * function node */
     for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t))
       ft->attrs = move_attr(ft->attrs, t->attrs, ATTR_CALLCONV);
-    if (is_object_interface && !is_attr(ft->attrs, ATTR_CALLCONV))
-    {
-      static char *stdmethodcalltype;
-      if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
-      ft->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
-    }
   }
   else
   {
@@ -6009,6 +6003,12 @@ static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, at
   else if (is_attr(attrs, ATTR_UUID) && !is_attr(attrs, ATTR_PUBLIC))
     attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
 
+  /* Append the SWITCHTYPE attribute to a union if it does not already have one.  */
+  if (type_get_type_detect_alias(type) == TYPE_UNION &&
+      is_attr(attrs, ATTR_SWITCHTYPE) &&
+      !is_attr(type->attrs, ATTR_SWITCHTYPE))
+    type->attrs = append_attr(type->attrs, make_attrp(ATTR_SWITCHTYPE, get_attrp(attrs, ATTR_SWITCHTYPE)));
+
   LIST_FOR_EACH_ENTRY( decl, decls, const declarator_t, entry )
   {
 
index eaf2d28..96c57cb 100644 (file)
@@ -201,7 +201,7 @@ typedef union YYSTYPE
 {
 
 /* Line 1676 of yacc.c  */
-#line 154 "parser.y"
+#line 153 "parser.y"
 
        attr_t *attr;
        attr_list_t *attr_list;
index db071a7..2c85f41 100644 (file)
@@ -66,7 +66,6 @@
 #define YYERROR_VERBOSE
 
 static unsigned char pointer_default = RPC_FC_UP;
-static int is_object_interface = FALSE;
 
 typedef struct list typelist_t;
 struct typenode {
@@ -806,7 +805,6 @@ dispinterface: tDISPINTERFACE aIDENTIFIER   { $$ = get_type(TYPE_INTERFACE, $2, 0)
        ;
 
 dispinterfacehdr: attributes dispinterface     { attr_t *attrs;
-                                                 is_object_interface = TRUE;
                                                  $$ = $2;
                                                  check_def($$);
                                                  attrs = make_attr(ATTR_DISPINTERFACE);
@@ -836,7 +834,7 @@ dispinterfacedef: dispinterfacehdr '{'
        ;
 
 inherit:                                       { $$ = NULL; }
-       | ':' aKNOWNTYPE                        { $$ = find_type_or_error2($2, 0); is_object_interface = 1; }
+       | ':' aKNOWNTYPE                        { $$ = find_type_or_error2($2, 0); }
        ;
 
 interface: tINTERFACE aIDENTIFIER              { $$ = get_type(TYPE_INTERFACE, $2, 0); }
@@ -849,7 +847,6 @@ interfacehdr: attributes interface          { $$.interface = $2;
                                                    pointer_default = get_attrv($1, ATTR_POINTERDEFAULT);
                                                  check_def($2);
                                                  $2->attrs = check_iface_attrs($2->name, $1);
-                                                 is_object_interface = is_object($2);
                                                  $2->defined = TRUE;
                                                }
        ;
@@ -926,7 +923,8 @@ decl_spec_no_type:
 declarator:
          '*' m_type_qual_list declarator %prec PPTR
                                                { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
-       | callconv declarator                   { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
+       | callconv declarator                   { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1));
+                                                          else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
        | direct_declarator
        ;
 
@@ -944,7 +942,8 @@ direct_declarator:
 abstract_declarator:
          '*' m_type_qual_list m_abstract_declarator %prec PPTR
                                                { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
-       | callconv m_abstract_declarator        { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
+       | callconv m_abstract_declarator        { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1));
+                                                          else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
        | abstract_direct_declarator
        ;
 
@@ -952,7 +951,8 @@ abstract_declarator:
 abstract_declarator_no_direct:
          '*' m_type_qual_list m_any_declarator %prec PPTR
                                                { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
-       | callconv m_any_declarator             { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
+       | callconv m_any_declarator             { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1));
+                                                          else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
        ;
 
 /* abstract declarator or empty */
@@ -1572,12 +1572,6 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl
      * function node */
     for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t))
       ft->attrs = move_attr(ft->attrs, t->attrs, ATTR_CALLCONV);
-    if (is_object_interface && !is_attr(ft->attrs, ATTR_CALLCONV))
-    {
-      static char *stdmethodcalltype;
-      if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
-      ft->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
-    }
   }
   else
   {
@@ -1822,6 +1816,12 @@ static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, at
   else if (is_attr(attrs, ATTR_UUID) && !is_attr(attrs, ATTR_PUBLIC))
     attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
 
+  /* Append the SWITCHTYPE attribute to a union if it does not already have one.  */
+  if (type_get_type_detect_alias(type) == TYPE_UNION &&
+      is_attr(attrs, ATTR_SWITCHTYPE) &&
+      !is_attr(type->attrs, ATTR_SWITCHTYPE))
+    type->attrs = append_attr(type->attrs, make_attrp(ATTR_SWITCHTYPE, get_attrp(attrs, ATTR_SWITCHTYPE)));
+
   LIST_FOR_EACH_ENTRY( decl, decls, const declarator_t, entry )
   {
 
index b4a0328..6fe8b1a 100644 (file)
@@ -16,6 +16,7 @@
 #define yytext parser_text
 #define yywrap parser_wrap
 
+#line 20 "parser.yy.c"
 /* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
@@ -662,7 +663,7 @@ UUID *parse_uuid(const char *u)
  * The flexer starts here
  **************************************************************************
  */
-#line 666 "lex.parser_.c"
+#line 667 "parser.yy.c"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -818,7 +819,7 @@ YY_DECL
 
 #line 127 "parser.l"
 
-#line 822 "lex.parser_.c"
+#line 823 "parser.yy.c"
 
        if ( yy_init )
                {
@@ -1137,7 +1138,7 @@ YY_RULE_SETUP
 #line 210 "parser.l"
 ECHO;
        YY_BREAK
-#line 1141 "lex.parser_.c"
+#line 1142 "parser.yy.c"
 
        case YY_END_OF_BUFFER:
                {
index 30feca8..8cbdf8f 100644 (file)
@@ -280,7 +280,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx,
   int has_ret = !is_void(type_function_get_rettype(func->type));
   int has_full_pointer = is_full_pointer_function(func);
   const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV);
-  if (!callconv) callconv = "";
+  if (!callconv) callconv = "STDMETHODCALLTYPE";
 
   indent = 0;
   print_proxy( "static void __finally_%s_%s_Proxy( struct __proxy_frame *__frame )\n",
index 8541c5a..717e2c8 100644 (file)
@@ -873,7 +873,7 @@ static unsigned int write_procformatstring_type(FILE *file, int indent,
             print_file(file, indent, "0x4d,    /* FC_IN_PARAM */\n");
 
         print_file(file, indent, "0x01,\n");
-        print_file(file, indent, "NdrFcShort(0x%hx),\n", type->typestring_offset);
+        print_file(file, indent, "NdrFcShort(0x%hx),\n", (unsigned short)type->typestring_offset);
         size = 4; /* includes param type prefix */
     }
     return size;
@@ -1137,7 +1137,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *structure,
         print_file(file, 2, "0x%x, /* %s */\n", operator_type,
                    operator_type ? string_of_type(operator_type) : "no operators");
         print_file(file, 2, "NdrFcShort(0x%hx),\t/* offset = %d */\n",
-                   offset, offset);
+                   (unsigned short)offset, offset);
     }
     else
     {
@@ -1172,7 +1172,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *structure,
 
         print_file(file, 2, "0x%x, /* Corr desc: %s */\n", conftype, conftype_string);
         print_file(file, 2, "0x%x, /* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK");
-        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", callback_offset, callback_offset);
+        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)callback_offset, callback_offset);
     }
     return 4;
 }
@@ -1654,8 +1654,8 @@ static void write_user_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
     print_file(file, 2, "0x%x,\t/* Alignment= %d, Flags= %02x */\n",
                flags | (ualign - 1), ualign - 1, flags);
     print_file(file, 2, "NdrFcShort(0x%hx),\t/* Function offset= %hu */\n", funoff, funoff);
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", size, size);
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", usize, usize);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)size, size);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)usize, usize);
     *tfsoff += 8;
     reloff = absoff - *tfsoff;
     print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", reloff, reloff, absoff);
@@ -1786,8 +1786,8 @@ static int write_pointer_description_offsets(
              * note that MSDN states that for pointer layouts in structures,
              * this is a negative offset from the end of the structure, but
              * this statement is incorrect. all offsets are positive */
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Memory offset = %d */\n", *offset_in_memory, *offset_in_memory);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Buffer offset = %d */\n", *offset_in_buffer, *offset_in_buffer);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Memory offset = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Buffer offset = %d */\n", (unsigned short)*offset_in_buffer, *offset_in_buffer);
 
             memsize = type_memsize(type);
             *offset_in_memory += memsize;
@@ -1940,10 +1940,10 @@ static int write_fixed_array_pointer_descriptions(
 
             print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", RPC_FC_FIXED_REPEAT);
             print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Iterations = %d */\n", type_array_get_dim(type), type_array_get_dim(type));
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", increment_size, increment_size);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", pointer_count, pointer_count);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Iterations = %d */\n", (unsigned short)type_array_get_dim(type), type_array_get_dim(type));
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count);
             *typestring_offset += 10;
 
             pointer_count = write_pointer_description_offsets(
@@ -2014,9 +2014,9 @@ static int write_conformant_array_pointer_descriptions(
 
             print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT);
             print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", RPC_FC_FIXED_OFFSET);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", increment_size, increment_size);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", offset_in_memory, offset_in_memory);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", pointer_count, pointer_count);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)offset_in_memory, offset_in_memory);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count);
             *typestring_offset += 8;
 
             pointer_count = write_pointer_description_offsets(
@@ -2056,9 +2056,9 @@ static int write_varying_array_pointer_descriptions(
 
             print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT);
             print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", RPC_FC_VARIABLE_OFFSET);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", increment_size, increment_size);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", *offset_in_memory, *offset_in_memory);
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", pointer_count, pointer_count);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count);
             *typestring_offset += 8;
 
             pointer_count = write_pointer_description_offsets(
@@ -2221,7 +2221,7 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs,
         print_file(file, 2, "0x%x, /* FC_PAD */\n", RPC_FC_PAD);
         *typestring_offset += 2;
 
-        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", dim, dim);
+        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)dim, dim);
         *typestring_offset += 2;
 
         return start_offset;
@@ -2298,7 +2298,7 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t
         }
         else
         {
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", size, size);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)size, size);
             *typestring_offset += 2;
         }
 
@@ -2319,11 +2319,11 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t
             }
             else
             {
-                print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", dim, dim);
+                print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)dim, dim);
                 *typestring_offset += 2;
             }
 
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", elsize, elsize);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)elsize, elsize);
             *typestring_offset += 2;
         }
 
@@ -2349,7 +2349,7 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t
     else
     {
         unsigned int dim = size_is ? 0 : type_array_get_dim(type);
-        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", dim, dim);
+        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)dim, dim);
         *typestring_offset += 2;
         *typestring_offset
             += write_conf_or_var_desc(file, current_structure, baseoff,
@@ -2487,7 +2487,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
     print_start_tfs_comment(file, type, start_offset);
     print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc));
     print_file(file, 2, "0x%x,\t/* %d */\n", align - 1, align - 1);
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", total_size, total_size);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)total_size, total_size);
     *tfsoff += 4;
 
     if (array)
@@ -2513,7 +2513,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
         int reloff = absoff - *tfsoff;
         assert( reloff >= 0 );
         print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %d (%u) */\n",
-                   reloff, reloff, absoff);
+                   (unsigned short)reloff, reloff, absoff);
         *tfsoff += 2;
     }
     else if ((fc == RPC_FC_PSTRUCT) ||
@@ -2713,8 +2713,8 @@ static unsigned int write_union_tfs(FILE *file, type_t *type, unsigned int *tfso
         print_file(file, 0, "/* %u */\n", *tfsoff);
     }
 
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", size, size);
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", nbranch, nbranch);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)size, size);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)nbranch, nbranch);
     *tfsoff += 4;
 
     if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
index cc25201..c4aa91f 100644 (file)
@@ -694,6 +694,7 @@ int main(int argc,char *argv[])
   if (do_server) server_token = dup_basename_token(server_name,"_s.c");
 
   add_widl_version_define();
+  wpp_add_define("_WIN32", NULL);
 
   atexit(rm_tempfile);
   if (!no_preprocess)
index 98da9cb..7e6b59c 100644 (file)
@@ -1,16 +1,6 @@
---- client.c   2008-09-27 21:56:02.000000000 +0200
-+++ client.c   2008-09-27 20:49:05.000000000 +0200
-@@ -113,7 +113,7 @@
-         }
-         if (explicit_handle)
-         {
--            if (!explicit_handle_var || !explicit_generic_handle_var || !context_handle_var)
-+            if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
-             {
-                 error("%s() does not define an explicit binding handle!\n", def->name);
-                 return;
---- hash.c     2008-09-27 21:56:02.000000000 +0200
-+++ hash.c     2008-09-22 00:14:35.703125000 +0200
+diff -u wine-1.3.4/tools/widl/hash.c tools/widl/hash.c
+--- wine-1.3.4/tools/widl/hash.c       2010-09-19 17:48:47.640625000 +0200
++++ tools/widl/hash.c  2010-09-19 19:17:19.000000000 +0200
 @@ -21,9 +21,7 @@
  #include <stdio.h>
  #include <stdarg.h>
 -#include "winnls.h"
 +#include <host/nls.h>
  
+ #include "widltypes.h"
  #include "hash.h"
-@@ -535,6 +533,7 @@
-   case LANG_SWEDISH:    case LANG_SYRIAC:     case LANG_TAMIL:
-   case LANG_TATAR:      case LANG_TELUGU:     case LANG_THAI:
-   case LANG_UKRAINIAN:  case LANG_URDU:       case LANG_UZBEK:
-+#ifndef __REACTOS__
-   case LANG_VIETNAMESE: case LANG_GAELIC:     case LANG_MALTESE:
-   case LANG_TAJIK:      case LANG_ROMANSH:    case LANG_IRISH:
-   case LANG_SAMI:       case LANG_UPPER_SORBIAN: case LANG_SUTU:
-@@ -542,6 +541,12 @@
-   case LANG_XHOSA:      case LANG_ZULU:       case LANG_ESPERANTO:
-   case LANG_WALON:      case LANG_CORNISH:    case LANG_WELSH:
-   case LANG_BRETON:
-+#else
-+  case LANG_VIETNAMESE: case LANG_MALTESE:    case LANG_IRISH:
-+  case LANG_SAMI:       case LANG_UPPER_SORBIAN:  case LANG_TSWANA:
-+  case LANG_XHOSA:      case LANG_ZULU:       case LANG_WELSH:
-+  case LANG_BRETON:
-+#endif
-     nOffset = 16;
-     pnLookup = Lookup_16;
-     break;
---- header.c   2008-09-27 21:56:02.000000000 +0200
-+++ header.c   2008-09-27 20:49:05.000000000 +0200
-@@ -891,6 +891,8 @@
-   const char *implicit_handle = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
-   int explicit_handle = is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE);
-   const var_t* explicit_handle_var;
-+  const var_t* explicit_generic_handle_var = NULL;
-+  const var_t* context_handle_var = NULL;
-   const func_t *cur;
-   int prefixes_differ = strcmp(prefix_client, prefix_server);
-@@ -901,8 +903,14 @@
-     /* check for a defined binding handle */
-     explicit_handle_var = get_explicit_handle_var(cur);
-+    if (!explicit_handle_var)
-+    {
-+      explicit_generic_handle_var = get_explicit_generic_handle_var(cur);
-+      if (!explicit_generic_handle_var)
-+        context_handle_var = get_context_handle_var(cur);
-+    }
-     if (explicit_handle) {
--      if (!explicit_handle_var) {
-+      if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var) {
-         error("%s() does not define an explicit binding handle!\n", def->name);
-         return;
-       }
---- header.h   2008-09-27 21:56:02.000000000 +0200
-+++ header.h   2008-09-23 21:14:50.781250000 +0200
-@@ -66,6 +66,7 @@
- extern const var_t* get_explicit_handle_var(const func_t* func);
- extern const type_t* get_explicit_generic_handle_type(const var_t* var);
- extern const var_t* get_explicit_generic_handle_var(const func_t* func);
-+extern const var_t* get_context_handle_var(const func_t* func);
- extern int has_out_arg_or_return(const func_t *func);
- extern void write_guid(FILE *f, const char *guid_prefix, const char *name,
-                        const UUID *uuid);
-@@ -88,11 +89,19 @@
- static inline int is_context_handle(const type_t *type)
- {
--    const type_t *t;
--    for (t = type; is_ptr(t); t = t->ref)
--        if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
-+    if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
-+        return 1;
+diff -u wine-1.3.4/tools/widl/parser.y tools/widl/parser.y
+--- wine-1.3.4/tools/widl/parser.y     2010-09-19 17:49:40.578125000 +0200
++++ tools/widl/parser.y        2010-10-03 16:44:18.781250000 +0200
+@@ -1816,6 +1816,12 @@
+   else if (is_attr(attrs, ATTR_UUID) && !is_attr(attrs, ATTR_PUBLIC))
+     attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
++  /* Append the SWITCHTYPE attribute to a union if it does not already have one.  */
++  if (type_get_type_detect_alias(type) == TYPE_UNION &&
++      is_attr(attrs, ATTR_SWITCHTYPE) &&
++      !is_attr(type->attrs, ATTR_SWITCHTYPE))
++    type->attrs = append_attr(type->attrs, make_attrp(ATTR_SWITCHTYPE, get_attrp(attrs, ATTR_SWITCHTYPE)));
 +
-+    for (;;)
-+    {
-+        if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
-             return 1;
--    return 0;
-+        else if (type->kind == TKIND_ALIAS)
-+            type = type->orig;
-+        else if (is_ptr(type))
-+            type = type->ref;
-+        else return 0;
-+    }
- }
- #endif
---- proxy.c    2008-09-27 21:56:02.000000000 +0200
-+++ proxy.c    2008-09-27 20:49:05.000000000 +0200
-@@ -463,41 +463,45 @@
-   print_proxy("\n");
- }
--static int write_proxy_methods(type_t *iface)
-+static int write_proxy_methods(type_t *iface, int skip)
- {
-   const func_t *cur;
-   int i = 0;
--  if (iface->ref) i = write_proxy_methods(iface->ref);
-+  if (iface->ref) i = write_proxy_methods(iface->ref, iface->ref->ref != NULL);
-   if (iface->funcs) LIST_FOR_EACH_ENTRY( cur, iface->funcs, const func_t, entry ) {
-     var_t *def = cur->def;
-     if (!is_callas(def->attrs)) {
-       if (i) fprintf(proxy, ",\n");
--      print_proxy( "%s_", iface->name);
-+      print_proxy( "%s%s_", skip ? "0\t/* " : "", iface->name);
-       write_name(proxy, def);
--      fprintf(proxy, "_Proxy");
-+      fprintf(proxy, "_Proxy%s", skip ? " */" : "");
-       i++;
-     }
-   }
-   return i;
- }
+   LIST_FOR_EACH_ENTRY( decl, decls, const declarator_t, entry )
+   {
  
--static int write_stub_methods(type_t *iface)
-+static int write_stub_methods(type_t *iface, int skip)
- {
-   const func_t *cur;
-   int i = 0;
--  if (iface->ref) i = write_stub_methods(iface->ref);
-+  if (iface->ref) i = write_stub_methods(iface->ref, TRUE);
-   else return i; /* skip IUnknown */
-   if (iface->funcs) LIST_FOR_EACH_ENTRY( cur, iface->funcs, const func_t, entry ) {
-     var_t *def = cur->def;
-     if (!is_local(def->attrs)) {
--      if (i) fprintf(proxy,",\n");
--      print_proxy( "%s_", iface->name);
--      write_name(proxy, def);
--      fprintf(proxy, "_Stub");
--      i++;
-+      if (skip)
-+        print_proxy("STUB_FORWARDING_FUNCTION,\n");
-+      else {
-+        if (i) fprintf(proxy,",\n");
-+        print_proxy( "%s_", iface->name);
-+        write_name(proxy, def);
-+        fprintf(proxy, "_Stub");
-+        i++;
-+      }
-     }
-   }
-   return i;
-@@ -551,7 +555,7 @@
-   print_proxy( "},\n");
-   print_proxy( "{\n");
-   indent++;
--  write_proxy_methods(iface);
-+  write_proxy_methods(iface, FALSE);
-   fprintf(proxy, "\n");
-   indent--;
-   print_proxy( "}\n");
-@@ -563,7 +567,7 @@
-   print_proxy( "static const PRPC_STUB_FUNCTION %s_table[] =\n", iface->name);
-   print_proxy( "{\n");
-   indent++;
--  stubs = write_stub_methods(iface);
-+  stubs = write_stub_methods(iface, FALSE);
-   fprintf(proxy, "\n");
-   indent--;
-   fprintf(proxy, "};\n");
---- server.c   2008-09-27 21:56:02.000000000 +0200
-+++ server.c   2008-09-27 20:49:05.000000000 +0200
-@@ -60,13 +60,21 @@
-     LIST_FOR_EACH_ENTRY( func, iface->funcs, const func_t, entry )
-     {
-         const var_t *def = func->def;
-+        const var_t* context_handle_var = NULL;
-+        const var_t* explicit_generic_handle_var = NULL;
-         int has_full_pointer = is_full_pointer_function(func);
-         /* check for a defined binding handle */
-         explicit_handle_var = get_explicit_handle_var(func);
-+        if (!explicit_handle_var)
-+        {
-+            explicit_generic_handle_var = get_explicit_generic_handle_var(func);
-+            if (!explicit_generic_handle_var)
-+                context_handle_var = get_context_handle_var(func);
-+        }
-         if (explicit_handle)
-         {
--            if (!explicit_handle_var)
-+            if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
-             {
-                 error("%s() does not define an explicit binding handle!\n", def->name);
-                 return;
-@@ -399,6 +407,7 @@
-     print_server("/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n", PACKAGE_VERSION, input_name);
-     print_server("#include <string.h>\n");
-     fprintf(server, "\n");
-+    print_server("#define _SEH_NO_NATIVE_NLG\n");
-     print_server("#include \"%s\"\n", header_name);
-     fprintf(server, "\n");
- }
---- typelib.c  2008-09-27 21:56:02.000000000 +0200
-+++ typelib.c  2008-09-27 20:49:05.000000000 +0200
+diff -u wine-1.3.4/tools/widl/typelib.c tools/widl/typelib.c
+--- wine-1.3.4/tools/widl/typelib.c    2010-09-19 17:50:24.000000000 +0200
++++ tools/widl/typelib.c       2010-09-26 20:23:47.000000000 +0200
 @@ -35,8 +35,7 @@
  #define NONAMELESSUNION
  #define NONAMELESSSTRUCT
  
  #include "widl.h"
  #include "utils.h"
-@@ -360,10 +359,10 @@
-     file_name = wpp_find_include(importlib->name, NULL);
-     if(file_name) {
--        fd = open(file_name, O_RDONLY);
-+        fd = open(file_name, O_RDONLY | O_BINARY);
-         free(file_name);
-     }else {
--        fd = open(importlib->name, O_RDONLY);
-+        fd = open(importlib->name, O_RDONLY | O_BINARY);
-     }
-     if(fd < 0)
---- typelib_struct.h   2008-09-27 21:56:02.000000000 +0200
-+++ typelib_struct.h   2008-09-22 00:14:35.703125000 +0200
+diff -u wine-1.3.4/tools/widl/typelib_struct.h tools/widl/typelib_struct.h
+--- wine-1.3.4/tools/widl/typelib_struct.h     2010-09-19 17:50:40.953125000 +0200
++++ tools/widl/typelib_struct.h        2010-10-10 00:50:32.921875000 +0200
 @@ -302,7 +302,7 @@
   *
   */
  
  /*---------------------------END--------------------------------------------*/
  #endif
---- widl.c     2008-09-27 21:56:02.000000000 +0200
-+++ widl.c     2008-09-27 20:49:05.000000000 +0200
-@@ -174,7 +174,7 @@
-   token = xstrdup(name);
-   for (i=0; token[i]; i++) {
-     if (!isalnum(token[i])) token[i] = '_';
--    else token[i] = toupper(token[i]);
-+    else token[i] = tolower(token[i]);
-   }
-   return token;
- }
-@@ -561,8 +561,8 @@
-     fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n", PACKAGE_VERSION, input_name);
-     fprintf(header, "#include <rpc.h>\n" );
-     fprintf(header, "#include <rpcndr.h>\n\n" );
--    fprintf(header, "#ifndef __WIDL_%s\n", header_token);
--    fprintf(header, "#define __WIDL_%s\n", header_token);
-+    fprintf(header, "#ifndef __%s__\n", header_token);
-+    fprintf(header, "#define __%s__\n", header_token);
-     start_cplusplus_guard(header);
-   }
-@@ -607,7 +607,7 @@
-     fprintf(header, "/* End additional prototypes */\n");
-     fprintf(header, "\n");
-     end_cplusplus_guard(header);
--    fprintf(header, "#endif /* __WIDL_%s */\n", header_token);
-+    fprintf(header, "#endif /* __%s__ */\n", header_token);
-     fclose(header);
-   }
---- widltypes.h        2008-09-27 21:56:02.000000000 +0200
-+++ widltypes.h        2008-09-26 19:42:52.859375000 +0200
+diff -u wine-1.3.4/tools/widl/widltypes.h tools/widl/widltypes.h
+--- wine-1.3.4/tools/widl/widltypes.h  2010-09-19 17:51:38.890625000 +0200
++++ tools/widl/widltypes.h     2010-09-19 19:17:19.656250000 +0200
 @@ -21,6 +21,13 @@
  #ifndef __WIDL_WIDLTYPES_H
  #define __WIDL_WIDLTYPES_H
 +#define max(a, b) ((a) > (b) ? a : b)
 +
  #include <stdarg.h>
+ #include <assert.h>
  #include "guiddef.h"
- #include "wine/rpcfc.h"
-@@ -31,7 +38,9 @@
+@@ -32,7 +39,9 @@
  typedef GUID UUID;
  #endif
  
 +#endif
  #define FALSE 0
  
- #define RPC_FC_FUNCTION 0xfe
---- write_msft.c       2008-09-27 21:56:02.000000000 +0200
-+++ write_msft.c       2008-09-27 20:49:05.000000000 +0200
+ typedef struct _loc_info_t loc_info_t;
+diff -u wine-1.3.4/tools/widl/write_msft.c tools/widl/write_msft.c
+--- wine-1.3.4/tools/widl/write_msft.c 2010-09-19 17:51:48.531250000 +0200
++++ tools/widl/write_msft.c    2010-09-26 20:23:47.000000000 +0200
 @@ -40,10 +40,8 @@
  #define NONAMELESSUNION
  #define NONAMELESSSTRUCT
 +#include <host/typedefs.h>
 +#include <host/nls.h>
  
- #include "widltypes.h"
+ #include "widl.h"
  #include "typelib.h"
index 74f3105..1bceb05 100644 (file)
@@ -21,9 +21,9 @@
 #ifndef __WIDL_WIDLTYPES_H
 #define __WIDL_WIDLTYPES_H
 
-#define S_OK           0        
-#define S_FALSE        1        
-#define E_OUTOFMEMORY  ((HRESULT)0x8007000EL)   
+#define S_OK           0
+#define S_FALSE        1
+#define E_OUTOFMEMORY  ((HRESULT)0x8007000EL)
 #define TYPE_E_IOERROR ((HRESULT)0x80028CA2L)
 
 #define max(a, b) ((a) > (b) ? a : b)
@@ -39,7 +39,9 @@
 typedef GUID UUID;
 #endif
 
+#ifndef TRUE
 #define TRUE 1
+#endif
 #define FALSE 0
 
 typedef struct _loc_info_t loc_info_t;