[WIDL]
authorEric Kohl <eric.kohl@reactos.org>
Sat, 9 Oct 2010 23:13:57 +0000 (23:13 +0000)
committerEric Kohl <eric.kohl@reactos.org>
Sat, 9 Oct 2010 23:13:57 +0000 (23:13 +0000)
- Revert r49085 and r49086.

svn path=/trunk/; revision=49087

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 bc99050..62f4d2e 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_3_4
+reactos/tools/widl                # Synced to Wine-1_2rc6
 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 e1a5196..8511ce5 100644 (file)
@@ -513,22 +513,27 @@ 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;
@@ -591,6 +596,7 @@ 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;
@@ -628,6 +634,7 @@ 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 eaef867..91ea2a0 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;
@@ -369,12 +366,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 && is_object_interface) callconv = "STDMETHODCALLTYPE";
+      if (!callconv) callconv = "";
       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);
-      if (callconv) fprintf(h, "%s ", callconv);
+      fprintf(h, "%s ", callconv);
       for (i = 0; i < ptr_level; i++)
         fputc('*', h);
     } else
@@ -399,7 +396,7 @@ static void write_type_v(FILE *h, type_t *t, int is_field, int declonly, const c
   }
 }
 
-static void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
+void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *name)
 {
   write_type_v(f, t, field, FALSE, name);
 }
@@ -788,7 +785,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 = "STDMETHODCALLTYPE";
+      if (!callconv) callconv = "";
       indent(header, 0);
       fprintf(header, "virtual ");
       write_type_decl_left(header, type_function_get_rettype(func->type));
@@ -818,7 +815,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 = "STDMETHODCALLTYPE";
+      if (!callconv) callconv = "";
       indent(header, 0);
       write_type_decl_left(header, type_function_get_rettype(func->type));
       fprintf(header, " (%s *%s)(\n", callconv, get_name(func));
@@ -849,7 +846,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 = "STDMETHODCALLTYPE";
+      if (!callconv) callconv = "";
       /* 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));
@@ -1220,7 +1217,6 @@ 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);
@@ -1233,7 +1229,6 @@ 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);
@@ -1309,14 +1304,16 @@ 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);
-
-  fprintf(header, "/* Forward declarations */\n\n");
-  write_forward_decls(header, stmts);
+  start_cplusplus_guard(header);
 
   fprintf(header, "/* Headers for imported files */\n\n");
   write_imports(header, stmts);
   fprintf(header, "\n");
-  start_cplusplus_guard(header);
+
+  /* FIXME: should be before imported file includes */
+  fprintf(header, "/* Forward declarations */\n\n");
+  write_forward_decls(header, stmts);
+  fprintf(header, "\n");
 
   write_header_stmts(header, stmts, NULL, FALSE);
 
index 2175f5e..97a2726 100644 (file)
@@ -34,6 +34,7 @@ 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 5c9137b..057bab5 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 {
@@ -231,7 +232,7 @@ static statement_list_t *append_statement(statement_list_t *list, statement_t *s
 
 
 /* Line 189 of yacc.c  */
-#line 235 "parser.tab.c"
+#line 228 "parser.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -420,7 +421,7 @@ typedef union YYSTYPE
 {
 
 /* Line 214 of yacc.c  */
-#line 153 "parser.y"
+#line 154 "parser.y"
 
        attr_t *attr;
        attr_list_t *attr_list;
@@ -450,7 +451,7 @@ typedef union YYSTYPE
 
 
 /* Line 214 of yacc.c  */
-#line 454 "parser.tab.c"
+#line 447 "parser.tab.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -462,7 +463,7 @@ typedef union YYSTYPE
 
 
 /* Line 264 of yacc.c  */
-#line 466 "parser.tab.c"
+#line 459 "parser.tab.c"
 
 #ifdef short
 # undef short
@@ -896,36 +897,36 @@ static const yytype_int16 yyrhs[] =
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       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,
+       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,
      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,
@@ -2653,7 +2654,7 @@ yyreduce:
         case 2:
 
 /* Line 1455 of yacc.c  */
-#line 325 "parser.y"
+#line 326 "parser.y"
     { fix_incomplete();
                                                  check_statements((yyvsp[(1) - (1)].stmt_list), FALSE);
                                                  check_all_user_types((yyvsp[(1) - (1)].stmt_list));
@@ -2670,28 +2671,28 @@ yyreduce:
   case 3:
 
 /* Line 1455 of yacc.c  */
-#line 338 "parser.y"
+#line 339 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 4:
 
 /* Line 1455 of yacc.c  */
-#line 339 "parser.y"
+#line 340 "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 340 "parser.y"
+#line 341 "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 341 "parser.y"
+#line 342 "parser.y"
     { (yyval.stmt_list) = (yyvsp[(1) - (3)].stmt_list);
                                                  reg_type((yyvsp[(2) - (3)].type), (yyvsp[(2) - (3)].type)->name, 0);
                                                ;}
@@ -2700,7 +2701,7 @@ yyreduce:
   case 7:
 
 /* Line 1455 of yacc.c  */
-#line 344 "parser.y"
+#line 345 "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);
                                                ;}
@@ -2709,56 +2710,56 @@ yyreduce:
   case 8:
 
 /* Line 1455 of yacc.c  */
-#line 347 "parser.y"
+#line 348 "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 348 "parser.y"
+#line 349 "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 349 "parser.y"
+#line 350 "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 352 "parser.y"
+#line 353 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 12:
 
 /* Line 1455 of yacc.c  */
-#line 353 "parser.y"
+#line 354 "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 354 "parser.y"
+#line 355 "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 355 "parser.y"
+#line 356 "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 356 "parser.y"
+#line 357 "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);
                                                ;}
@@ -2767,112 +2768,112 @@ yyreduce:
   case 16:
 
 /* Line 1455 of yacc.c  */
-#line 359 "parser.y"
+#line 360 "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 360 "parser.y"
+#line 361 "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 361 "parser.y"
+#line 362 "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 362 "parser.y"
+#line 363 "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 365 "parser.y"
+#line 366 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 21:
 
 /* Line 1455 of yacc.c  */
-#line 366 "parser.y"
+#line 367 "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 374 "parser.y"
+#line 375 "parser.y"
     { (yyval.statement) = make_statement_cppquote((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 25:
 
 /* Line 1455 of yacc.c  */
-#line 375 "parser.y"
+#line 376 "parser.y"
     { (yyval.statement) = make_statement_type_decl((yyvsp[(1) - (2)].type)); ;}
     break;
 
   case 26:
 
 /* Line 1455 of yacc.c  */
-#line 376 "parser.y"
+#line 377 "parser.y"
     { (yyval.statement) = make_statement_declaration((yyvsp[(1) - (2)].var)); ;}
     break;
 
   case 27:
 
 /* Line 1455 of yacc.c  */
-#line 377 "parser.y"
+#line 378 "parser.y"
     { (yyval.statement) = make_statement_import((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 28:
 
 /* Line 1455 of yacc.c  */
-#line 378 "parser.y"
+#line 379 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (2)].statement); ;}
     break;
 
   case 32:
 
 /* Line 1455 of yacc.c  */
-#line 385 "parser.y"
+#line 386 "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 386 "parser.y"
+#line 387 "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 387 "parser.y"
+#line 388 "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 390 "parser.y"
+#line 391 "parser.y"
     { (yyval.str) = (yyvsp[(3) - (4)].str); ;}
     break;
 
   case 36:
 
 /* Line 1455 of yacc.c  */
-#line 392 "parser.y"
+#line 393 "parser.y"
     { assert(yychar == YYEMPTY);
                                                  (yyval.import) = xmalloc(sizeof(struct _import_t));
                                                  (yyval.import)->name = (yyvsp[(2) - (3)].str);
@@ -2884,7 +2885,7 @@ yyreduce:
   case 37:
 
 /* Line 1455 of yacc.c  */
-#line 400 "parser.y"
+#line 401 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (3)].import)->name;
                                                  if ((yyvsp[(1) - (3)].import)->import_performed) pop_import();
                                                  free((yyvsp[(1) - (3)].import));
@@ -2894,21 +2895,21 @@ yyreduce:
   case 38:
 
 /* Line 1455 of yacc.c  */
-#line 407 "parser.y"
+#line 408 "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 410 "parser.y"
+#line 411 "parser.y"
     { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
     break;
 
   case 40:
 
 /* Line 1455 of yacc.c  */
-#line 412 "parser.y"
+#line 413 "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));
                                                ;}
@@ -2917,7 +2918,7 @@ yyreduce:
   case 41:
 
 /* Line 1455 of yacc.c  */
-#line 417 "parser.y"
+#line 418 "parser.y"
     { (yyval.typelib) = (yyvsp[(1) - (4)].typelib);
                                                  (yyval.typelib)->stmts = (yyvsp[(2) - (4)].stmt_list);
                                                  if (!parse_only) end_typelib();
@@ -2927,35 +2928,35 @@ yyreduce:
   case 42:
 
 /* Line 1455 of yacc.c  */
-#line 423 "parser.y"
+#line 424 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 44:
 
 /* Line 1455 of yacc.c  */
-#line 427 "parser.y"
+#line 428 "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 428 "parser.y"
+#line 429 "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 432 "parser.y"
+#line 433 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), make_var(strdup("...")) ); ;}
     break;
 
   case 48:
 
 /* Line 1455 of yacc.c  */
-#line 436 "parser.y"
+#line 437 "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);
@@ -2966,7 +2967,7 @@ yyreduce:
   case 49:
 
 /* Line 1455 of yacc.c  */
-#line 441 "parser.y"
+#line 442 "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);
@@ -2977,455 +2978,455 @@ yyreduce:
   case 50:
 
 /* Line 1455 of yacc.c  */
-#line 448 "parser.y"
+#line 449 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
     break;
 
   case 51:
 
 /* Line 1455 of yacc.c  */
-#line 449 "parser.y"
+#line 450 "parser.y"
     { (yyval.expr) = make_expr(EXPR_VOID); ;}
     break;
 
   case 52:
 
 /* Line 1455 of yacc.c  */
-#line 452 "parser.y"
+#line 453 "parser.y"
     { (yyval.attr_list) = NULL; ;}
     break;
 
   case 54:
 
 /* Line 1455 of yacc.c  */
-#line 457 "parser.y"
+#line 458 "parser.y"
     { (yyval.attr_list) = (yyvsp[(2) - (3)].attr_list); ;}
     break;
 
   case 55:
 
 /* Line 1455 of yacc.c  */
-#line 460 "parser.y"
+#line 461 "parser.y"
     { (yyval.attr_list) = append_attr( NULL, (yyvsp[(1) - (1)].attr) ); ;}
     break;
 
   case 56:
 
 /* Line 1455 of yacc.c  */
-#line 461 "parser.y"
+#line 462 "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 462 "parser.y"
+#line 463 "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 465 "parser.y"
+#line 466 "parser.y"
     { (yyval.str_list) = append_str( NULL, (yyvsp[(1) - (1)].str) ); ;}
     break;
 
   case 59:
 
 /* Line 1455 of yacc.c  */
-#line 466 "parser.y"
+#line 467 "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 469 "parser.y"
+#line 470 "parser.y"
     { (yyval.attr) = NULL; ;}
     break;
 
   case 61:
 
 /* Line 1455 of yacc.c  */
-#line 470 "parser.y"
+#line 471 "parser.y"
     { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); ;}
     break;
 
   case 62:
 
 /* Line 1455 of yacc.c  */
-#line 471 "parser.y"
+#line 472 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 63:
 
 /* Line 1455 of yacc.c  */
-#line 472 "parser.y"
+#line 473 "parser.y"
     { (yyval.attr) = make_attr(ATTR_APPOBJECT); ;}
     break;
 
   case 64:
 
 /* Line 1455 of yacc.c  */
-#line 473 "parser.y"
+#line 474 "parser.y"
     { (yyval.attr) = make_attr(ATTR_ASYNC); ;}
     break;
 
   case 65:
 
 /* Line 1455 of yacc.c  */
-#line 474 "parser.y"
+#line 475 "parser.y"
     { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); ;}
     break;
 
   case 66:
 
 /* Line 1455 of yacc.c  */
-#line 475 "parser.y"
+#line 476 "parser.y"
     { (yyval.attr) = make_attr(ATTR_BINDABLE); ;}
     break;
 
   case 67:
 
 /* Line 1455 of yacc.c  */
-#line 476 "parser.y"
+#line 477 "parser.y"
     { (yyval.attr) = make_attr(ATTR_BROADCAST); ;}
     break;
 
   case 68:
 
 /* Line 1455 of yacc.c  */
-#line 477 "parser.y"
+#line 478 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[(3) - (4)].var)); ;}
     break;
 
   case 69:
 
 /* Line 1455 of yacc.c  */
-#line 478 "parser.y"
+#line 479 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 70:
 
 /* Line 1455 of yacc.c  */
-#line 479 "parser.y"
+#line 480 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); ;}
     break;
 
   case 71:
 
 /* Line 1455 of yacc.c  */
-#line 480 "parser.y"
+#line 481 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ ;}
     break;
 
   case 72:
 
 /* Line 1455 of yacc.c  */
-#line 481 "parser.y"
+#line 482 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ ;}
     break;
 
   case 73:
 
 /* Line 1455 of yacc.c  */
-#line 482 "parser.y"
+#line 483 "parser.y"
     { (yyval.attr) = make_attr(ATTR_CONTROL); ;}
     break;
 
   case 74:
 
 /* Line 1455 of yacc.c  */
-#line 483 "parser.y"
+#line 484 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DEFAULT); ;}
     break;
 
   case 75:
 
 /* Line 1455 of yacc.c  */
-#line 484 "parser.y"
+#line 485 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); ;}
     break;
 
   case 76:
 
 /* Line 1455 of yacc.c  */
-#line 485 "parser.y"
+#line 486 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 77:
 
 /* Line 1455 of yacc.c  */
-#line 486 "parser.y"
+#line 487 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); ;}
     break;
 
   case 78:
 
 /* Line 1455 of yacc.c  */
-#line 487 "parser.y"
+#line 488 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); ;}
     break;
 
   case 79:
 
 /* Line 1455 of yacc.c  */
-#line 488 "parser.y"
+#line 489 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 80:
 
 /* Line 1455 of yacc.c  */
-#line 489 "parser.y"
+#line 490 "parser.y"
     { (yyval.attr) = make_attr(ATTR_DUAL); ;}
     break;
 
   case 81:
 
 /* Line 1455 of yacc.c  */
-#line 490 "parser.y"
+#line 491 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[(3) - (4)].str_list)); ;}
     break;
 
   case 82:
 
 /* Line 1455 of yacc.c  */
-#line 491 "parser.y"
+#line 492 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 83:
 
 /* Line 1455 of yacc.c  */
-#line 492 "parser.y"
+#line 493 "parser.y"
     { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); ;}
     break;
 
   case 84:
 
 /* Line 1455 of yacc.c  */
-#line 493 "parser.y"
+#line 494 "parser.y"
     { (yyval.attr) = make_attr(ATTR_HANDLE); ;}
     break;
 
   case 85:
 
 /* Line 1455 of yacc.c  */
-#line 494 "parser.y"
+#line 495 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 86:
 
 /* Line 1455 of yacc.c  */
-#line 495 "parser.y"
+#line 496 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 87:
 
 /* Line 1455 of yacc.c  */
-#line 496 "parser.y"
+#line 497 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 88:
 
 /* Line 1455 of yacc.c  */
-#line 497 "parser.y"
+#line 498 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 89:
 
 /* Line 1455 of yacc.c  */
-#line 498 "parser.y"
+#line 499 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 90:
 
 /* Line 1455 of yacc.c  */
-#line 499 "parser.y"
+#line 500 "parser.y"
     { (yyval.attr) = make_attr(ATTR_HIDDEN); ;}
     break;
 
   case 91:
 
 /* Line 1455 of yacc.c  */
-#line 500 "parser.y"
+#line 501 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 92:
 
 /* Line 1455 of yacc.c  */
-#line 501 "parser.y"
+#line 502 "parser.y"
     { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); ;}
     break;
 
   case 93:
 
 /* Line 1455 of yacc.c  */
-#line 502 "parser.y"
+#line 503 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 94:
 
 /* Line 1455 of yacc.c  */
-#line 503 "parser.y"
+#line 504 "parser.y"
     { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); ;}
     break;
 
   case 95:
 
 /* Line 1455 of yacc.c  */
-#line 504 "parser.y"
+#line 505 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[(4) - (5)].str)); ;}
     break;
 
   case 96:
 
 /* Line 1455 of yacc.c  */
-#line 505 "parser.y"
+#line 506 "parser.y"
     { (yyval.attr) = make_attr(ATTR_IN); ;}
     break;
 
   case 97:
 
 /* Line 1455 of yacc.c  */
-#line 506 "parser.y"
+#line 507 "parser.y"
     { (yyval.attr) = make_attr(ATTR_INPUTSYNC); ;}
     break;
 
   case 98:
 
 /* Line 1455 of yacc.c  */
-#line 507 "parser.y"
+#line 508 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 99:
 
 /* Line 1455 of yacc.c  */
-#line 508 "parser.y"
+#line 509 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 100:
 
 /* Line 1455 of yacc.c  */
-#line 509 "parser.y"
+#line 510 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PARAMLCID); ;}
     break;
 
   case 101:
 
 /* Line 1455 of yacc.c  */
-#line 510 "parser.y"
+#line 511 "parser.y"
     { (yyval.attr) = make_attr(ATTR_LOCAL); ;}
     break;
 
   case 102:
 
 /* Line 1455 of yacc.c  */
-#line 511 "parser.y"
+#line 512 "parser.y"
     { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;}
     break;
 
   case 103:
 
 /* Line 1455 of yacc.c  */
-#line 512 "parser.y"
+#line 513 "parser.y"
     { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;}
     break;
 
   case 104:
 
 /* Line 1455 of yacc.c  */
-#line 513 "parser.y"
+#line 514 "parser.y"
     { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;}
     break;
 
   case 105:
 
 /* Line 1455 of yacc.c  */
-#line 514 "parser.y"
+#line 515 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OBJECT); ;}
     break;
 
   case 106:
 
 /* Line 1455 of yacc.c  */
-#line 515 "parser.y"
+#line 516 "parser.y"
     { (yyval.attr) = make_attr(ATTR_ODL); ;}
     break;
 
   case 107:
 
 /* Line 1455 of yacc.c  */
-#line 516 "parser.y"
+#line 517 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;}
     break;
 
   case 108:
 
 /* Line 1455 of yacc.c  */
-#line 517 "parser.y"
+#line 518 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;}
     break;
 
   case 109:
 
 /* Line 1455 of yacc.c  */
-#line 518 "parser.y"
+#line 519 "parser.y"
     { (yyval.attr) = make_attr(ATTR_OUT); ;}
     break;
 
   case 110:
 
 /* Line 1455 of yacc.c  */
-#line 519 "parser.y"
+#line 520 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[(3) - (4)].num)); ;}
     break;
 
   case 111:
 
 /* Line 1455 of yacc.c  */
-#line 520 "parser.y"
+#line 521 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPGET); ;}
     break;
 
   case 112:
 
 /* Line 1455 of yacc.c  */
-#line 521 "parser.y"
+#line 522 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPPUT); ;}
     break;
 
   case 113:
 
 /* Line 1455 of yacc.c  */
-#line 522 "parser.y"
+#line 523 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPPUTREF); ;}
     break;
 
   case 114:
 
 /* Line 1455 of yacc.c  */
-#line 523 "parser.y"
+#line 524 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PUBLIC); ;}
     break;
 
   case 115:
 
 /* Line 1455 of yacc.c  */
-#line 525 "parser.y"
+#line 526 "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); ;}
@@ -3434,126 +3435,126 @@ yyreduce:
   case 116:
 
 /* Line 1455 of yacc.c  */
-#line 528 "parser.y"
+#line 529 "parser.y"
     { (yyval.attr) = make_attr(ATTR_READONLY); ;}
     break;
 
   case 117:
 
 /* Line 1455 of yacc.c  */
-#line 529 "parser.y"
+#line 530 "parser.y"
     { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); ;}
     break;
 
   case 118:
 
 /* Line 1455 of yacc.c  */
-#line 530 "parser.y"
+#line 531 "parser.y"
     { (yyval.attr) = make_attr(ATTR_RESTRICTED); ;}
     break;
 
   case 119:
 
 /* Line 1455 of yacc.c  */
-#line 531 "parser.y"
+#line 532 "parser.y"
     { (yyval.attr) = make_attr(ATTR_RETVAL); ;}
     break;
 
   case 120:
 
 /* Line 1455 of yacc.c  */
-#line 532 "parser.y"
+#line 533 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 121:
 
 /* Line 1455 of yacc.c  */
-#line 533 "parser.y"
+#line 534 "parser.y"
     { (yyval.attr) = make_attr(ATTR_SOURCE); ;}
     break;
 
   case 122:
 
 /* Line 1455 of yacc.c  */
-#line 534 "parser.y"
+#line 535 "parser.y"
     { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); ;}
     break;
 
   case 123:
 
 /* Line 1455 of yacc.c  */
-#line 535 "parser.y"
+#line 536 "parser.y"
     { (yyval.attr) = make_attr(ATTR_STRING); ;}
     break;
 
   case 124:
 
 /* Line 1455 of yacc.c  */
-#line 536 "parser.y"
+#line 537 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 125:
 
 /* Line 1455 of yacc.c  */
-#line 537 "parser.y"
+#line 538 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 126:
 
 /* Line 1455 of yacc.c  */
-#line 538 "parser.y"
+#line 539 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 127:
 
 /* Line 1455 of yacc.c  */
-#line 539 "parser.y"
+#line 540 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[(3) - (4)].uuid)); ;}
     break;
 
   case 128:
 
 /* Line 1455 of yacc.c  */
-#line 540 "parser.y"
+#line 541 "parser.y"
     { (yyval.attr) = make_attr(ATTR_V1ENUM); ;}
     break;
 
   case 129:
 
 /* Line 1455 of yacc.c  */
-#line 541 "parser.y"
+#line 542 "parser.y"
     { (yyval.attr) = make_attr(ATTR_VARARG); ;}
     break;
 
   case 130:
 
 /* Line 1455 of yacc.c  */
-#line 542 "parser.y"
+#line 543 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[(3) - (4)].num)); ;}
     break;
 
   case 131:
 
 /* Line 1455 of yacc.c  */
-#line 543 "parser.y"
+#line 544 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 132:
 
 /* Line 1455 of yacc.c  */
-#line 544 "parser.y"
+#line 545 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 134:
 
 /* Line 1455 of yacc.c  */
-#line 549 "parser.y"
+#line 550 "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)); ;}
@@ -3562,49 +3563,49 @@ yyreduce:
   case 135:
 
 /* Line 1455 of yacc.c  */
-#line 554 "parser.y"
+#line 555 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 136:
 
 /* Line 1455 of yacc.c  */
-#line 555 "parser.y"
+#line 556 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 137:
 
 /* Line 1455 of yacc.c  */
-#line 556 "parser.y"
+#line 557 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 138:
 
 /* Line 1455 of yacc.c  */
-#line 557 "parser.y"
+#line 558 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 139:
 
 /* Line 1455 of yacc.c  */
-#line 560 "parser.y"
+#line 561 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 140:
 
 /* Line 1455 of yacc.c  */
-#line 561 "parser.y"
+#line 562 "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 564 "parser.y"
+#line 565 "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 );
@@ -3614,7 +3615,7 @@ yyreduce:
   case 142:
 
 /* Line 1455 of yacc.c  */
-#line 568 "parser.y"
+#line 569 "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 );
@@ -3624,21 +3625,21 @@ yyreduce:
   case 143:
 
 /* Line 1455 of yacc.c  */
-#line 574 "parser.y"
+#line 575 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 144:
 
 /* Line 1455 of yacc.c  */
-#line 575 "parser.y"
+#line 576 "parser.y"
     { (yyval.var_list) = (yyvsp[(1) - (2)].var_list); ;}
     break;
 
   case 146:
 
 /* Line 1455 of yacc.c  */
-#line 579 "parser.y"
+#line 580 "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) );
@@ -3648,7 +3649,7 @@ yyreduce:
   case 147:
 
 /* Line 1455 of yacc.c  */
-#line 583 "parser.y"
+#line 584 "parser.y"
     { if (!(yyvsp[(3) - (3)].var)->eval)
                                                   {
                                                     var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry );
@@ -3661,7 +3662,7 @@ yyreduce:
   case 148:
 
 /* Line 1455 of yacc.c  */
-#line 592 "parser.y"
+#line 593 "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);
@@ -3671,7 +3672,7 @@ yyreduce:
   case 149:
 
 /* Line 1455 of yacc.c  */
-#line 596 "parser.y"
+#line 597 "parser.y"
     { (yyval.var) = reg_const((yyvsp[(1) - (1)].var));
                                                   (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0);
                                                ;}
@@ -3680,336 +3681,336 @@ yyreduce:
   case 150:
 
 /* Line 1455 of yacc.c  */
-#line 601 "parser.y"
+#line 602 "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 604 "parser.y"
+#line 605 "parser.y"
     { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
     break;
 
   case 152:
 
 /* Line 1455 of yacc.c  */
-#line 605 "parser.y"
+#line 606 "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 618 "parser.y"
+#line 619 "parser.y"
     { (yyval.expr) = make_expr(EXPR_VOID); ;}
     break;
 
   case 155:
 
 /* Line 1455 of yacc.c  */
-#line 622 "parser.y"
+#line 623 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 156:
 
 /* Line 1455 of yacc.c  */
-#line 623 "parser.y"
+#line 624 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 157:
 
 /* Line 1455 of yacc.c  */
-#line 624 "parser.y"
+#line 625 "parser.y"
     { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[(1) - (1)].dbl)); ;}
     break;
 
   case 158:
 
 /* Line 1455 of yacc.c  */
-#line 625 "parser.y"
+#line 626 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); ;}
     break;
 
   case 159:
 
 /* Line 1455 of yacc.c  */
-#line 626 "parser.y"
+#line 627 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_NUM, 0); ;}
     break;
 
   case 160:
 
 /* Line 1455 of yacc.c  */
-#line 627 "parser.y"
+#line 628 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); ;}
     break;
 
   case 161:
 
 /* Line 1455 of yacc.c  */
-#line 628 "parser.y"
+#line 629 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 162:
 
 /* Line 1455 of yacc.c  */
-#line 629 "parser.y"
+#line 630 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 163:
 
 /* Line 1455 of yacc.c  */
-#line 630 "parser.y"
+#line 631 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 164:
 
 /* Line 1455 of yacc.c  */
-#line 631 "parser.y"
+#line 632 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 165:
 
 /* Line 1455 of yacc.c  */
-#line 632 "parser.y"
+#line 633 "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 633 "parser.y"
+#line 634 "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 634 "parser.y"
+#line 635 "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 635 "parser.y"
+#line 636 "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 636 "parser.y"
+#line 637 "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 637 "parser.y"
+#line 638 "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 638 "parser.y"
+#line 639 "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 639 "parser.y"
+#line 640 "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 640 "parser.y"
+#line 641 "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 641 "parser.y"
+#line 642 "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 642 "parser.y"
+#line 643 "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 643 "parser.y"
+#line 644 "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 644 "parser.y"
+#line 645 "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 645 "parser.y"
+#line 646 "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 646 "parser.y"
+#line 647 "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 647 "parser.y"
+#line 648 "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 648 "parser.y"
+#line 649 "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 649 "parser.y"
+#line 650 "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 650 "parser.y"
+#line 651 "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 651 "parser.y"
+#line 652 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 185:
 
 /* Line 1455 of yacc.c  */
-#line 652 "parser.y"
+#line 653 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 186:
 
 /* Line 1455 of yacc.c  */
-#line 653 "parser.y"
+#line 654 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 187:
 
 /* Line 1455 of yacc.c  */
-#line 654 "parser.y"
+#line 655 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 188:
 
 /* Line 1455 of yacc.c  */
-#line 655 "parser.y"
+#line 656 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 189:
 
 /* Line 1455 of yacc.c  */
-#line 656 "parser.y"
+#line 657 "parser.y"
     { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 190:
 
 /* Line 1455 of yacc.c  */
-#line 657 "parser.y"
+#line 658 "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 658 "parser.y"
+#line 659 "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 660 "parser.y"
+#line 661 "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 662 "parser.y"
+#line 663 "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 663 "parser.y"
+#line 664 "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 664 "parser.y"
+#line 665 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
     break;
 
   case 196:
 
 /* Line 1455 of yacc.c  */
-#line 667 "parser.y"
+#line 668 "parser.y"
     { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
     break;
 
   case 197:
 
 /* Line 1455 of yacc.c  */
-#line 668 "parser.y"
+#line 669 "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 671 "parser.y"
+#line 672 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);
                                                  if (!(yyval.expr)->is_const)
                                                      error_loc("expression is not an integer constant\n");
@@ -4019,7 +4020,7 @@ yyreduce:
   case 199:
 
 /* Line 1455 of yacc.c  */
-#line 677 "parser.y"
+#line 678 "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");
@@ -4029,21 +4030,21 @@ yyreduce:
   case 200:
 
 /* Line 1455 of yacc.c  */
-#line 683 "parser.y"
+#line 684 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 201:
 
 /* Line 1455 of yacc.c  */
-#line 684 "parser.y"
+#line 685 "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 688 "parser.y"
+#line 689 "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));
@@ -4053,7 +4054,7 @@ yyreduce:
   case 203:
 
 /* Line 1455 of yacc.c  */
-#line 692 "parser.y"
+#line 693 "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);
@@ -4063,49 +4064,49 @@ yyreduce:
   case 204:
 
 /* Line 1455 of yacc.c  */
-#line 699 "parser.y"
+#line 700 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (2)].var); ;}
     break;
 
   case 205:
 
 /* Line 1455 of yacc.c  */
-#line 700 "parser.y"
+#line 701 "parser.y"
     { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[(1) - (2)].attr_list); ;}
     break;
 
   case 206:
 
 /* Line 1455 of yacc.c  */
-#line 703 "parser.y"
+#line 704 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 207:
 
 /* Line 1455 of yacc.c  */
-#line 704 "parser.y"
+#line 705 "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 708 "parser.y"
+#line 709 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (2)].var); ;}
     break;
 
   case 209:
 
 /* Line 1455 of yacc.c  */
-#line 709 "parser.y"
+#line 710 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
   case 210:
 
 /* Line 1455 of yacc.c  */
-#line 712 "parser.y"
+#line 713 "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));
@@ -4115,7 +4116,7 @@ yyreduce:
   case 211:
 
 /* Line 1455 of yacc.c  */
-#line 718 "parser.y"
+#line 719 "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");
@@ -4126,7 +4127,7 @@ yyreduce:
   case 212:
 
 /* Line 1455 of yacc.c  */
-#line 727 "parser.y"
+#line 728 "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));
                                                ;}
@@ -4135,7 +4136,7 @@ yyreduce:
   case 213:
 
 /* Line 1455 of yacc.c  */
-#line 730 "parser.y"
+#line 731 "parser.y"
     { (yyval.var) = declare_var(NULL, (yyvsp[(1) - (2)].declspec), (yyvsp[(2) - (2)].declarator), FALSE);
                                                  free((yyvsp[(2) - (2)].declarator));
                                                ;}
@@ -4144,182 +4145,182 @@ yyreduce:
   case 214:
 
 /* Line 1455 of yacc.c  */
-#line 735 "parser.y"
+#line 736 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
   case 216:
 
 /* Line 1455 of yacc.c  */
-#line 739 "parser.y"
+#line 740 "parser.y"
     { (yyval.str) = NULL; ;}
     break;
 
   case 217:
 
 /* Line 1455 of yacc.c  */
-#line 740 "parser.y"
+#line 741 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 218:
 
 /* Line 1455 of yacc.c  */
-#line 741 "parser.y"
+#line 742 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 219:
 
 /* Line 1455 of yacc.c  */
-#line 744 "parser.y"
+#line 745 "parser.y"
     { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 220:
 
 /* Line 1455 of yacc.c  */
-#line 746 "parser.y"
+#line 747 "parser.y"
     { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 221:
 
 /* Line 1455 of yacc.c  */
-#line 749 "parser.y"
+#line 750 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 222:
 
 /* Line 1455 of yacc.c  */
-#line 750 "parser.y"
+#line 751 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 224:
 
 /* Line 1455 of yacc.c  */
-#line 752 "parser.y"
+#line 753 "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 753 "parser.y"
+#line 754 "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 754 "parser.y"
+#line 755 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); ;}
     break;
 
   case 227:
 
 /* Line 1455 of yacc.c  */
-#line 755 "parser.y"
+#line 756 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 228:
 
 /* Line 1455 of yacc.c  */
-#line 756 "parser.y"
+#line 757 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 229:
 
 /* Line 1455 of yacc.c  */
-#line 757 "parser.y"
+#line 758 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 230:
 
 /* Line 1455 of yacc.c  */
-#line 758 "parser.y"
+#line 759 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 231:
 
 /* Line 1455 of yacc.c  */
-#line 759 "parser.y"
+#line 760 "parser.y"
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 234:
 
 /* Line 1455 of yacc.c  */
-#line 766 "parser.y"
+#line 767 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); ;}
     break;
 
   case 235:
 
 /* Line 1455 of yacc.c  */
-#line 767 "parser.y"
+#line 768 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); ;}
     break;
 
   case 236:
 
 /* Line 1455 of yacc.c  */
-#line 768 "parser.y"
+#line 769 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); ;}
     break;
 
   case 237:
 
 /* Line 1455 of yacc.c  */
-#line 769 "parser.y"
+#line 770 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); ;}
     break;
 
   case 238:
 
 /* Line 1455 of yacc.c  */
-#line 770 "parser.y"
+#line 771 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); ;}
     break;
 
   case 239:
 
 /* Line 1455 of yacc.c  */
-#line 771 "parser.y"
+#line 772 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); ;}
     break;
 
   case 240:
 
 /* Line 1455 of yacc.c  */
-#line 772 "parser.y"
+#line 773 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); ;}
     break;
 
   case 241:
 
 /* Line 1455 of yacc.c  */
-#line 773 "parser.y"
+#line 774 "parser.y"
     { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); ;}
     break;
 
   case 242:
 
 /* Line 1455 of yacc.c  */
-#line 776 "parser.y"
+#line 777 "parser.y"
     { (yyval.type) = type_new_coclass((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 243:
 
 /* Line 1455 of yacc.c  */
-#line 777 "parser.y"
+#line 778 "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",
@@ -4331,7 +4332,7 @@ yyreduce:
   case 244:
 
 /* Line 1455 of yacc.c  */
-#line 785 "parser.y"
+#line 786 "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));
@@ -4341,50 +4342,51 @@ yyreduce:
   case 245:
 
 /* Line 1455 of yacc.c  */
-#line 792 "parser.y"
+#line 793 "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 795 "parser.y"
+#line 796 "parser.y"
     { (yyval.ifref_list) = NULL; ;}
     break;
 
   case 247:
 
 /* Line 1455 of yacc.c  */
-#line 796 "parser.y"
+#line 797 "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 800 "parser.y"
+#line 801 "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 803 "parser.y"
+#line 804 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 250:
 
 /* Line 1455 of yacc.c  */
-#line 804 "parser.y"
+#line 805 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 251:
 
 /* Line 1455 of yacc.c  */
-#line 807 "parser.y"
+#line 808 "parser.y"
     { attr_t *attrs;
+                                                 is_object_interface = TRUE;
                                                  (yyval.type) = (yyvsp[(2) - (2)].type);
                                                  check_def((yyval.type));
                                                  attrs = make_attr(ATTR_DISPINTERFACE);
@@ -4396,35 +4398,35 @@ yyreduce:
   case 252:
 
 /* Line 1455 of yacc.c  */
-#line 816 "parser.y"
+#line 818 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 253:
 
 /* Line 1455 of yacc.c  */
-#line 817 "parser.y"
+#line 819 "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 820 "parser.y"
+#line 822 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
   case 255:
 
 /* Line 1455 of yacc.c  */
-#line 821 "parser.y"
+#line 823 "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 827 "parser.y"
+#line 829 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                  type_dispinterface_define((yyval.type), (yyvsp[(3) - (5)].var_list), (yyvsp[(4) - (5)].var_list));
                                                ;}
@@ -4433,7 +4435,7 @@ yyreduce:
   case 257:
 
 /* Line 1455 of yacc.c  */
-#line 831 "parser.y"
+#line 833 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                  type_dispinterface_define_from_iface((yyval.type), (yyvsp[(3) - (5)].type));
                                                ;}
@@ -4442,41 +4444,42 @@ yyreduce:
   case 258:
 
 /* Line 1455 of yacc.c  */
-#line 836 "parser.y"
+#line 838 "parser.y"
     { (yyval.type) = NULL; ;}
     break;
 
   case 259:
 
 /* Line 1455 of yacc.c  */
-#line 837 "parser.y"
-    { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); ;}
+#line 839 "parser.y"
+    { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); is_object_interface = 1; ;}
     break;
 
   case 260:
 
 /* Line 1455 of yacc.c  */
-#line 840 "parser.y"
+#line 842 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 261:
 
 /* Line 1455 of yacc.c  */
-#line 841 "parser.y"
+#line 843 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
   case 262:
 
 /* Line 1455 of yacc.c  */
-#line 844 "parser.y"
+#line 846 "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;
@@ -4484,7 +4487,7 @@ yyreduce:
   case 263:
 
 /* Line 1455 of yacc.c  */
-#line 855 "parser.y"
+#line 858 "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;
@@ -4494,7 +4497,7 @@ yyreduce:
   case 264:
 
 /* Line 1455 of yacc.c  */
-#line 863 "parser.y"
+#line 866 "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;
@@ -4504,42 +4507,42 @@ yyreduce:
   case 265:
 
 /* Line 1455 of yacc.c  */
-#line 867 "parser.y"
+#line 870 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 266:
 
 /* Line 1455 of yacc.c  */
-#line 871 "parser.y"
+#line 874 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 267:
 
 /* Line 1455 of yacc.c  */
-#line 872 "parser.y"
+#line 875 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 268:
 
 /* Line 1455 of yacc.c  */
-#line 875 "parser.y"
+#line 878 "parser.y"
     { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 269:
 
 /* Line 1455 of yacc.c  */
-#line 876 "parser.y"
+#line 879 "parser.y"
     { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 270:
 
 /* Line 1455 of yacc.c  */
-#line 879 "parser.y"
+#line 882 "parser.y"
     { (yyval.type) = (yyvsp[(2) - (2)].type);
                                                  (yyval.type)->attrs = check_module_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list));
                                                ;}
@@ -4548,7 +4551,7 @@ yyreduce:
   case 271:
 
 /* Line 1455 of yacc.c  */
-#line 885 "parser.y"
+#line 888 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                   type_module_define((yyval.type), (yyvsp[(3) - (5)].stmt_list));
                                                ;}
@@ -4557,134 +4560,133 @@ yyreduce:
   case 272:
 
 /* Line 1455 of yacc.c  */
-#line 891 "parser.y"
+#line 894 "parser.y"
     { (yyval.stgclass) = STG_EXTERN; ;}
     break;
 
   case 273:
 
 /* Line 1455 of yacc.c  */
-#line 892 "parser.y"
+#line 895 "parser.y"
     { (yyval.stgclass) = STG_STATIC; ;}
     break;
 
   case 274:
 
 /* Line 1455 of yacc.c  */
-#line 893 "parser.y"
+#line 896 "parser.y"
     { (yyval.stgclass) = STG_REGISTER; ;}
     break;
 
   case 275:
 
 /* Line 1455 of yacc.c  */
-#line 897 "parser.y"
+#line 900 "parser.y"
     { (yyval.attr) = make_attr(ATTR_INLINE); ;}
     break;
 
   case 276:
 
 /* Line 1455 of yacc.c  */
-#line 901 "parser.y"
+#line 904 "parser.y"
     { (yyval.attr) = make_attr(ATTR_CONST); ;}
     break;
 
   case 277:
 
 /* Line 1455 of yacc.c  */
-#line 904 "parser.y"
+#line 907 "parser.y"
     { (yyval.attr_list) = NULL; ;}
     break;
 
   case 278:
 
 /* Line 1455 of yacc.c  */
-#line 905 "parser.y"
+#line 908 "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 908 "parser.y"
+#line 911 "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 910 "parser.y"
+#line 913 "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 913 "parser.y"
+#line 916 "parser.y"
     { (yyval.declspec) = NULL; ;}
     break;
 
   case 283:
 
 /* Line 1455 of yacc.c  */
-#line 918 "parser.y"
+#line 921 "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 919 "parser.y"
+#line 922 "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 920 "parser.y"
+#line 923 "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 925 "parser.y"
+#line 928 "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 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))); ;}
+#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))); ;}
     break;
 
   case 289:
 
 /* Line 1455 of yacc.c  */
-#line 932 "parser.y"
+#line 934 "parser.y"
     { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); ;}
     break;
 
   case 290:
 
 /* Line 1455 of yacc.c  */
-#line 933 "parser.y"
+#line 935 "parser.y"
     { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;}
     break;
 
   case 291:
 
 /* Line 1455 of yacc.c  */
-#line 934 "parser.y"
+#line 936 "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 935 "parser.y"
+#line 937 "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;
@@ -4694,31 +4696,29 @@ yyreduce:
   case 293:
 
 /* Line 1455 of yacc.c  */
-#line 944 "parser.y"
+#line 946 "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 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))); ;}
+#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))); ;}
     break;
 
   case 296:
 
 /* Line 1455 of yacc.c  */
-#line 953 "parser.y"
+#line 954 "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 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))); ;}
+#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))); ;}
     break;
 
   case 298:
@@ -5056,7 +5056,7 @@ yyreduce:
 
 
 /* Line 1455 of yacc.c  */
-#line 5060 "parser.tab.c"
+#line 5052 "parser.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -5759,6 +5759,12 @@ 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
   {
@@ -6003,12 +6009,6 @@ 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 96c57cb..eaf2d28 100644 (file)
@@ -201,7 +201,7 @@ typedef union YYSTYPE
 {
 
 /* Line 1676 of yacc.c  */
-#line 153 "parser.y"
+#line 154 "parser.y"
 
        attr_t *attr;
        attr_list_t *attr_list;
index 2c85f41..db071a7 100644 (file)
@@ -66,6 +66,7 @@
 #define YYERROR_VERBOSE
 
 static unsigned char pointer_default = RPC_FC_UP;
+static int is_object_interface = FALSE;
 
 typedef struct list typelist_t;
 struct typenode {
@@ -805,6 +806,7 @@ 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);
@@ -834,7 +836,7 @@ dispinterfacedef: dispinterfacehdr '{'
        ;
 
 inherit:                                       { $$ = NULL; }
-       | ':' aKNOWNTYPE                        { $$ = find_type_or_error2($2, 0); }
+       | ':' aKNOWNTYPE                        { $$ = find_type_or_error2($2, 0); is_object_interface = 1; }
        ;
 
 interface: tINTERFACE aIDENTIFIER              { $$ = get_type(TYPE_INTERFACE, $2, 0); }
@@ -847,6 +849,7 @@ 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;
                                                }
        ;
@@ -923,8 +926,7 @@ 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; 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)); }
+       | callconv declarator                   { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
        | direct_declarator
        ;
 
@@ -942,8 +944,7 @@ 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; 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)); }
+       | callconv m_abstract_declarator        { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
        | abstract_direct_declarator
        ;
 
@@ -951,8 +952,7 @@ 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; 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)); }
+       | callconv m_any_declarator             { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
        ;
 
 /* abstract declarator or empty */
@@ -1572,6 +1572,12 @@ 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
   {
@@ -1816,12 +1822,6 @@ 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 6fe8b1a..b4a0328 100644 (file)
@@ -16,7 +16,6 @@
 #define yytext parser_text
 #define yywrap parser_wrap
 
-#line 20 "parser.yy.c"
 /* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
@@ -663,7 +662,7 @@ UUID *parse_uuid(const char *u)
  * The flexer starts here
  **************************************************************************
  */
-#line 667 "parser.yy.c"
+#line 666 "lex.parser_.c"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -819,7 +818,7 @@ YY_DECL
 
 #line 127 "parser.l"
 
-#line 823 "parser.yy.c"
+#line 822 "lex.parser_.c"
 
        if ( yy_init )
                {
@@ -1138,7 +1137,7 @@ YY_RULE_SETUP
 #line 210 "parser.l"
 ECHO;
        YY_BREAK
-#line 1142 "parser.yy.c"
+#line 1141 "lex.parser_.c"
 
        case YY_END_OF_BUFFER:
                {
index 8cbdf8f..30feca8 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 = "STDMETHODCALLTYPE";
+  if (!callconv) callconv = "";
 
   indent = 0;
   print_proxy( "static void __finally_%s_%s_Proxy( struct __proxy_frame *__frame )\n",
index 717e2c8..8541c5a 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", (unsigned short)type->typestring_offset);
+        print_file(file, indent, "NdrFcShort(0x%hx),\n", 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",
-                   (unsigned short)offset, offset);
+                   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", (unsigned short)callback_offset, callback_offset);
+        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", 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", (unsigned short)size, size);
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)usize, usize);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", size, size);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", 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", (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);
+            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);
 
             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", (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);
+            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);
             *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", (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);
+            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);
             *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", (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);
+            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);
             *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", (unsigned short)dim, dim);
+        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", 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", (unsigned short)size, size);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", 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", (unsigned short)dim, dim);
+                print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", dim, dim);
                 *typestring_offset += 2;
             }
 
-            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)elsize, elsize);
+            print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", 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", (unsigned short)dim, dim);
+        print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", 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", (unsigned short)total_size, total_size);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", 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",
-                   (unsigned short)reloff, reloff, absoff);
+                   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", (unsigned short)size, size);
-    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)nbranch, nbranch);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", size, size);
+    print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", nbranch, nbranch);
     *tfsoff += 4;
 
     if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
index c4aa91f..cc25201 100644 (file)
@@ -694,7 +694,6 @@ 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 7e6b59c..98da9cb 100644 (file)
@@ -1,6 +1,16 @@
-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
+--- 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
 @@ -21,9 +21,7 @@
  #include <stdio.h>
  #include <stdarg.h>
@@ -10,27 +20,202 @@ diff -u wine-1.3.4/tools/widl/hash.c tools/widl/hash.c
 -#include "winnls.h"
 +#include <host/nls.h>
  
- #include "widltypes.h"
  #include "hash.h"
-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)));
+@@ -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;
 +
-   LIST_FOR_EACH_ENTRY( decl, decls, const declarator_t, entry )
-   {
++    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;
+ }
  
-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
+-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
 @@ -35,8 +35,7 @@
  #define NONAMELESSUNION
  #define NONAMELESSSTRUCT
@@ -41,9 +226,21 @@ diff -u wine-1.3.4/tools/widl/typelib.c tools/widl/typelib.c
  
  #include "widl.h"
  #include "utils.h"
-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
+@@ -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
 @@ -302,7 +302,7 @@
   *
   */
@@ -62,9 +259,39 @@ diff -u wine-1.3.4/tools/widl/typelib_struct.h tools/widl/typelib_struct.h
  
  /*---------------------------END--------------------------------------------*/
  #endif
-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
+--- 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
 @@ -21,6 +21,13 @@
  #ifndef __WIDL_WIDLTYPES_H
  #define __WIDL_WIDLTYPES_H
@@ -77,9 +304,9 @@ diff -u wine-1.3.4/tools/widl/widltypes.h tools/widl/widltypes.h
 +#define max(a, b) ((a) > (b) ? a : b)
 +
  #include <stdarg.h>
- #include <assert.h>
  #include "guiddef.h"
-@@ -32,7 +39,9 @@
+ #include "wine/rpcfc.h"
+@@ -31,7 +38,9 @@
  typedef GUID UUID;
  #endif
  
@@ -88,10 +315,9 @@ diff -u wine-1.3.4/tools/widl/widltypes.h tools/widl/widltypes.h
 +#endif
  #define FALSE 0
  
- 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
+ #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
 @@ -40,10 +40,8 @@
  #define NONAMELESSUNION
  #define NONAMELESSSTRUCT
@@ -103,5 +329,5 @@ diff -u wine-1.3.4/tools/widl/write_msft.c tools/widl/write_msft.c
 +#include <host/typedefs.h>
 +#include <host/nls.h>
  
- #include "widl.h"
+ #include "widltypes.h"
  #include "typelib.h"
index 1bceb05..74f3105 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,9 +39,7 @@
 typedef GUID UUID;
 #endif
 
-#ifndef TRUE
 #define TRUE 1
-#endif
 #define FALSE 0
 
 typedef struct _loc_info_t loc_info_t;