sync widl to wine 1.1.27
authorChristoph von Wittich <christoph_vw@reactos.org>
Sat, 8 Aug 2009 12:40:21 +0000 (12:40 +0000)
committerChristoph von Wittich <christoph_vw@reactos.org>
Sat, 8 Aug 2009 12:40:21 +0000 (12:40 +0000)
svn path=/trunk/; revision=42510

reactos/tools/widl/hash.c
reactos/tools/widl/parser.tab.c
reactos/tools/widl/parser.y
reactos/tools/widl/proxy.c
reactos/tools/widl/typegen.c
reactos/tools/widl/widltypes.h
reactos/tools/widl/write_msft.c

index 06a4f0c..551039c 100644 (file)
@@ -534,19 +534,37 @@ unsigned int lhash_val_of_name_sys( syskind_t skind, LCID lcid, LPCSTR lpStr)
   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:
-  case LANG_TSONGA:     case LANG_TSWANA:     case LANG_VENDA:
-  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_SAMI:       case LANG_UPPER_SORBIAN: case LANG_TSWANA:
   case LANG_XHOSA:      case LANG_ZULU:       case LANG_WELSH:
   case LANG_BRETON:
+/* some languages not in all windows versions or ReactOS */
+#ifdef LANG_GAELIC
+  case LANG_GAELIC:
+#endif
+#ifdef LANG_TAJIK
+  case LANG_TAJIK:
+#endif
+#ifdef LANG_ROMANSH
+  case LANG_ROMANSH:
+#endif
+#ifdef LANG_SUTU
+  case LANG_SUTU:
+#endif
+#ifdef LANG_TSONGA
+  case LANG_TSONGA:
+#endif
+#ifdef LANG_VENDA
+  case LANG_VENDA:
+#endif
+#ifdef LANG_ESPERANTO
+  case LANG_ESPERANTO:
+#endif
+#ifdef LANG_WALON
+  case LANG_WALON:
+#endif
+#ifdef LANG_CORNISH
+  case LANG_CORNISH:
 #endif
     nOffset = 16;
     pnLookup = Lookup_16;
index 3117fa1..c5962de 100644 (file)
@@ -685,7 +685,7 @@ union yyalloc
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  88
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  311
+#define YYNRULES  312
 /* YYNRULES -- Number of states.  */
 #define YYNSTATES  547
 
@@ -757,28 +757,28 @@ static const yytype_uint16 yyprhs[] =
      197,   199,   201,   203,   205,   207,   212,   214,   216,   221,
      223,   228,   233,   235,   237,   242,   247,   252,   257,   262,
      264,   269,   271,   276,   278,   284,   286,   288,   293,   298,
-     300,   302,   304,   306,   308,   310,   312,   314,   316,   321,
-     323,   325,   327,   329,   336,   338,   340,   342,   344,   349,
-     351,   353,   355,   360,   365,   370,   375,   377,   379,   384,
-     389,   391,   393,   395,   397,   399,   401,   403,   404,   407,
-     412,   416,   417,   420,   422,   424,   428,   432,   434,   440,
-     442,   446,   447,   449,   451,   453,   455,   457,   459,   461,
-     463,   465,   467,   473,   477,   481,   485,   489,   493,   497,
-     501,   505,   509,   513,   517,   521,   525,   529,   533,   537,
-     541,   545,   548,   551,   554,   557,   560,   563,   567,   571,
-     576,   581,   586,   590,   592,   596,   598,   600,   601,   604,
-     609,   613,   616,   619,   620,   623,   626,   628,   632,   636,
-     640,   643,   644,   646,   647,   649,   651,   653,   655,   657,
-     659,   661,   664,   667,   669,   671,   673,   675,   677,   679,
-     680,   682,   684,   687,   689,   692,   695,   697,   699,   702,
-     705,   708,   714,   715,   718,   721,   724,   727,   730,   733,
-     737,   740,   744,   750,   756,   757,   760,   763,   766,   769,
-     776,   785,   788,   791,   794,   797,   800,   803,   809,   811,
-     813,   815,   817,   819,   820,   823,   826,   830,   831,   833,
-     836,   839,   842,   846,   849,   851,   853,   857,   860,   865,
-     867,   871,   873,   877,   879,   881,   883,   889,   891,   893,
-     895,   897,   900,   902,   905,   907,   910,   915,   920,   926,
-     937,   939
+     300,   302,   304,   306,   308,   310,   312,   314,   316,   318,
+     323,   325,   327,   329,   331,   338,   340,   342,   344,   346,
+     351,   353,   355,   357,   362,   367,   372,   377,   379,   381,
+     386,   391,   393,   395,   397,   399,   401,   403,   405,   406,
+     409,   414,   418,   419,   422,   424,   426,   430,   434,   436,
+     442,   444,   448,   449,   451,   453,   455,   457,   459,   461,
+     463,   465,   467,   469,   475,   479,   483,   487,   491,   495,
+     499,   503,   507,   511,   515,   519,   523,   527,   531,   535,
+     539,   543,   547,   550,   553,   556,   559,   562,   565,   569,
+     573,   578,   583,   588,   592,   594,   598,   600,   602,   603,
+     606,   611,   615,   618,   621,   622,   625,   628,   630,   634,
+     638,   642,   645,   646,   648,   649,   651,   653,   655,   657,
+     659,   661,   663,   666,   669,   671,   673,   675,   677,   679,
+     681,   682,   684,   686,   689,   691,   694,   697,   699,   701,
+     704,   707,   710,   716,   717,   720,   723,   726,   729,   732,
+     735,   739,   742,   746,   752,   758,   759,   762,   765,   768,
+     771,   778,   787,   790,   793,   796,   799,   802,   805,   811,
+     813,   815,   817,   819,   821,   822,   825,   828,   832,   833,
+     835,   838,   841,   844,   848,   851,   853,   855,   859,   862,
+     867,   869,   873,   875,   879,   881,   883,   885,   891,   893,
+     895,   897,   899,   902,   904,   907,   909,   912,   917,   922,
+     928,   939,   941
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
@@ -813,72 +813,72 @@ static const yytype_int16 yyrhs[] =
      171,    -1,    71,    -1,    73,   170,   212,   171,    -1,    74,
       -1,    75,   170,   210,   171,    -1,    76,    -1,    77,   170,
       65,     3,   171,    -1,    80,    -1,    83,    -1,    88,   170,
-     208,   171,    -1,    87,   170,   212,   171,    -1,    90,    -1,
-      94,    -1,    95,    -1,    96,    -1,    98,    -1,    99,    -1,
-     100,    -1,   101,    -1,   102,    -1,   104,   170,   257,   171,
-      -1,   106,    -1,   107,    -1,   108,    -1,   110,    -1,   111,
-     170,   212,   146,   212,   171,    -1,   112,    -1,   115,    -1,
-     116,    -1,   117,    -1,   121,   170,   208,   171,    -1,   124,
-      -1,   127,    -1,   128,    -1,   131,   170,   210,   171,    -1,
-     132,   170,   259,   171,    -1,   133,   170,   259,   171,    -1,
-     139,   170,   200,   171,    -1,   140,    -1,   141,    -1,   142,
-     170,   262,   171,    -1,   145,   170,   259,   171,    -1,   257,
-      -1,    10,    -1,     8,    -1,    35,    -1,    62,    -1,   103,
-      -1,   126,    -1,    -1,   202,   203,    -1,    34,   212,   148,
-     218,    -1,    46,   148,   218,    -1,    -1,   205,   146,    -1,
-     205,    -1,   206,    -1,   205,   146,   206,    -1,   224,   174,
-     212,    -1,   224,    -1,    57,   223,   172,   204,   173,    -1,
-     209,    -1,   208,   146,   209,    -1,    -1,   210,    -1,     5,
-      -1,     6,    -1,     7,    -1,    61,    -1,    97,    -1,   134,
-      -1,     8,    -1,     9,    -1,     3,    -1,   210,   147,   210,
-     148,   210,    -1,   210,    19,   210,    -1,   210,    20,   210,
-      -1,   210,   149,   210,    -1,   210,   150,   210,    -1,   210,
-     151,   210,    -1,   210,    15,   210,    -1,   210,    16,   210,
-      -1,   210,   153,   210,    -1,   210,   152,   210,    -1,   210,
-      17,   210,    -1,   210,    18,   210,    -1,   210,    12,   210,
-      -1,   210,    13,   210,    -1,   210,   155,   210,    -1,   210,
-     154,   210,    -1,   210,   158,   210,    -1,   210,   156,   210,
-      -1,   210,   157,   210,    -1,   159,   210,    -1,   160,   210,
-      -1,   155,   210,    -1,   154,   210,    -1,   151,   210,    -1,
-     156,   210,    -1,   210,    14,     3,    -1,   210,   166,     3,
-      -1,   170,   259,   171,   210,    -1,   122,   170,   259,   171,
-      -1,   210,   167,   210,   168,    -1,   170,   210,   171,    -1,
-     212,    -1,   211,   146,   212,    -1,   210,    -1,   210,    -1,
-      -1,   214,   215,    -1,   195,   250,   255,   169,    -1,   195,
-     261,   169,    -1,   219,   169,    -1,   196,   169,    -1,    -1,
-     217,   216,    -1,   219,   169,    -1,   169,    -1,   195,   250,
-     253,    -1,   195,   250,   253,    -1,   196,   250,   256,    -1,
-     250,   256,    -1,    -1,   224,    -1,    -1,     3,    -1,     4,
-      -1,     3,    -1,     4,    -1,    30,    -1,   144,    -1,   227,
-      -1,   120,   227,    -1,   138,   227,    -1,   138,    -1,    63,
-      -1,    53,    -1,    28,    -1,    58,    -1,    65,    -1,    -1,
-      84,    -1,    84,    -1,   119,   226,    -1,   123,    -1,    91,
-     226,    -1,    72,   226,    -1,    85,    -1,    36,    -1,    37,
-       3,    -1,    37,     4,    -1,   196,   228,    -1,   229,   172,
-     231,   173,   180,    -1,    -1,   231,   232,    -1,   195,   242,
-      -1,    51,     3,    -1,    51,     4,    -1,   196,   233,    -1,
-     105,   148,    -1,   235,   219,   169,    -1,    92,   148,    -1,
-     236,   220,   169,    -1,   234,   172,   235,   236,   173,    -1,
-     234,   172,   239,   169,   173,    -1,    -1,   148,     4,    -1,
-      86,     3,    -1,    86,     4,    -1,   196,   239,    -1,   240,
-     238,   172,   179,   173,   180,    -1,   240,   148,     3,   172,
-     185,   179,   173,   180,    -1,   237,   180,    -1,   239,   169,
-      -1,   233,   169,    -1,    93,     3,    -1,    93,     4,    -1,
-     196,   243,    -1,   244,   172,   179,   173,   180,    -1,    60,
-      -1,   125,    -1,   114,    -1,    82,    -1,    40,    -1,    -1,
-     249,   248,    -1,   259,   251,    -1,   252,   259,   251,    -1,
-      -1,   252,    -1,   248,   251,    -1,   247,   251,    -1,   246,
-     251,    -1,   156,   249,   253,    -1,   201,   253,    -1,   254,
-      -1,   224,    -1,   170,   253,   171,    -1,   254,   194,    -1,
-     254,   170,   190,   171,    -1,   253,    -1,   255,   146,   253,
-      -1,   253,    -1,   253,   174,   213,    -1,   113,    -1,   137,
-      -1,   109,    -1,   129,   223,   172,   214,   173,    -1,   143,
-      -1,     4,    -1,   225,    -1,   207,    -1,    57,     3,    -1,
-     258,    -1,   129,     3,    -1,   261,    -1,   136,     3,    -1,
-     118,   170,   259,   171,    -1,   135,   195,   250,   255,    -1,
-     136,   223,   172,   217,   173,    -1,   136,   223,   130,   170,
-     219,   171,   222,   172,   202,   173,    -1,     5,    -1,     5,
-     166,     5,    -1
+     208,   171,    -1,    87,   170,   212,   171,    -1,    87,    -1,
+      90,    -1,    94,    -1,    95,    -1,    96,    -1,    98,    -1,
+      99,    -1,   100,    -1,   101,    -1,   102,    -1,   104,   170,
+     257,   171,    -1,   106,    -1,   107,    -1,   108,    -1,   110,
+      -1,   111,   170,   212,   146,   212,   171,    -1,   112,    -1,
+     115,    -1,   116,    -1,   117,    -1,   121,   170,   208,   171,
+      -1,   124,    -1,   127,    -1,   128,    -1,   131,   170,   210,
+     171,    -1,   132,   170,   259,   171,    -1,   133,   170,   259,
+     171,    -1,   139,   170,   200,   171,    -1,   140,    -1,   141,
+      -1,   142,   170,   262,   171,    -1,   145,   170,   259,   171,
+      -1,   257,    -1,    10,    -1,     8,    -1,    35,    -1,    62,
+      -1,   103,    -1,   126,    -1,    -1,   202,   203,    -1,    34,
+     212,   148,   218,    -1,    46,   148,   218,    -1,    -1,   205,
+     146,    -1,   205,    -1,   206,    -1,   205,   146,   206,    -1,
+     224,   174,   212,    -1,   224,    -1,    57,   223,   172,   204,
+     173,    -1,   209,    -1,   208,   146,   209,    -1,    -1,   210,
+      -1,     5,    -1,     6,    -1,     7,    -1,    61,    -1,    97,
+      -1,   134,    -1,     8,    -1,     9,    -1,     3,    -1,   210,
+     147,   210,   148,   210,    -1,   210,    19,   210,    -1,   210,
+      20,   210,    -1,   210,   149,   210,    -1,   210,   150,   210,
+      -1,   210,   151,   210,    -1,   210,    15,   210,    -1,   210,
+      16,   210,    -1,   210,   153,   210,    -1,   210,   152,   210,
+      -1,   210,    17,   210,    -1,   210,    18,   210,    -1,   210,
+      12,   210,    -1,   210,    13,   210,    -1,   210,   155,   210,
+      -1,   210,   154,   210,    -1,   210,   158,   210,    -1,   210,
+     156,   210,    -1,   210,   157,   210,    -1,   159,   210,    -1,
+     160,   210,    -1,   155,   210,    -1,   154,   210,    -1,   151,
+     210,    -1,   156,   210,    -1,   210,    14,     3,    -1,   210,
+     166,     3,    -1,   170,   259,   171,   210,    -1,   122,   170,
+     259,   171,    -1,   210,   167,   210,   168,    -1,   170,   210,
+     171,    -1,   212,    -1,   211,   146,   212,    -1,   210,    -1,
+     210,    -1,    -1,   214,   215,    -1,   195,   250,   255,   169,
+      -1,   195,   261,   169,    -1,   219,   169,    -1,   196,   169,
+      -1,    -1,   217,   216,    -1,   219,   169,    -1,   169,    -1,
+     195,   250,   253,    -1,   195,   250,   253,    -1,   196,   250,
+     256,    -1,   250,   256,    -1,    -1,   224,    -1,    -1,     3,
+      -1,     4,    -1,     3,    -1,     4,    -1,    30,    -1,   144,
+      -1,   227,    -1,   120,   227,    -1,   138,   227,    -1,   138,
+      -1,    63,    -1,    53,    -1,    28,    -1,    58,    -1,    65,
+      -1,    -1,    84,    -1,    84,    -1,   119,   226,    -1,   123,
+      -1,    91,   226,    -1,    72,   226,    -1,    85,    -1,    36,
+      -1,    37,     3,    -1,    37,     4,    -1,   196,   228,    -1,
+     229,   172,   231,   173,   180,    -1,    -1,   231,   232,    -1,
+     195,   242,    -1,    51,     3,    -1,    51,     4,    -1,   196,
+     233,    -1,   105,   148,    -1,   235,   219,   169,    -1,    92,
+     148,    -1,   236,   220,   169,    -1,   234,   172,   235,   236,
+     173,    -1,   234,   172,   239,   169,   173,    -1,    -1,   148,
+       4,    -1,    86,     3,    -1,    86,     4,    -1,   196,   239,
+      -1,   240,   238,   172,   179,   173,   180,    -1,   240,   148,
+       3,   172,   185,   179,   173,   180,    -1,   237,   180,    -1,
+     239,   169,    -1,   233,   169,    -1,    93,     3,    -1,    93,
+       4,    -1,   196,   243,    -1,   244,   172,   179,   173,   180,
+      -1,    60,    -1,   125,    -1,   114,    -1,    82,    -1,    40,
+      -1,    -1,   249,   248,    -1,   259,   251,    -1,   252,   259,
+     251,    -1,    -1,   252,    -1,   248,   251,    -1,   247,   251,
+      -1,   246,   251,    -1,   156,   249,   253,    -1,   201,   253,
+      -1,   254,    -1,   224,    -1,   170,   253,   171,    -1,   254,
+     194,    -1,   254,   170,   190,   171,    -1,   253,    -1,   255,
+     146,   253,    -1,   253,    -1,   253,   174,   213,    -1,   113,
+      -1,   137,    -1,   109,    -1,   129,   223,   172,   214,   173,
+      -1,   143,    -1,     4,    -1,   225,    -1,   207,    -1,    57,
+       3,    -1,   258,    -1,   129,     3,    -1,   261,    -1,   136,
+       3,    -1,   118,   170,   259,   171,    -1,   135,   195,   250,
+     255,    -1,   136,   223,   172,   217,   173,    -1,   136,   223,
+     130,   170,   219,   171,   222,   172,   202,   173,    -1,     5,
+      -1,     5,   166,     5,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
@@ -895,27 +895,27 @@ static const yytype_uint16 yyrline[] =
      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,   526,   530,   531,   532,   533,   534,   535,
+     523,   524,   525,   526,   527,   531,   532,   533,   534,   535,
      536,   537,   538,   539,   540,   541,   542,   543,   544,   545,
-     546,   550,   551,   556,   557,   558,   559,   562,   563,   566,
-     570,   576,   577,   578,   581,   585,   594,   598,   603,   606,
-     607,   620,   621,   624,   625,   626,   627,   628,   629,   630,
+     546,   547,   551,   552,   557,   558,   559,   560,   563,   564,
+     567,   571,   577,   578,   579,   582,   586,   595,   599,   604,
+     607,   608,   621,   622,   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,
-     661,   662,   663,   666,   667,   670,   676,   682,   683,   686,
-     691,   698,   699,   702,   703,   707,   708,   711,   719,   728,
-     734,   740,   741,   744,   745,   746,   749,   751,   754,   755,
-     756,   757,   758,   759,   760,   761,   762,   763,   764,   767,
-     768,   771,   772,   773,   774,   775,   776,   777,   780,   781,
-     789,   795,   799,   800,   804,   807,   808,   811,   821,   822,
-     825,   826,   829,   835,   841,   842,   845,   846,   849,   860,
-     867,   873,   877,   878,   881,   882,   885,   890,   897,   898,
-     899,   903,   907,   910,   911,   914,   915,   919,   920,   924,
-     925,   926,   930,   932,   933,   937,   938,   939,   940,   947,
-     948,   952,   953,   957,   958,   959,   962,   965,   966,   967,
-     968,   969,   970,   971,   972,   973,   974,   977,   983,   985,
-     991,   992
+     661,   662,   663,   664,   667,   668,   671,   677,   683,   684,
+     687,   692,   699,   700,   703,   704,   708,   709,   712,   720,
+     729,   735,   741,   742,   745,   746,   747,   750,   752,   755,
+     756,   757,   758,   759,   760,   761,   762,   763,   764,   765,
+     768,   769,   772,   773,   774,   775,   776,   777,   778,   781,
+     782,   790,   796,   800,   801,   805,   808,   809,   812,   822,
+     823,   826,   827,   830,   836,   842,   843,   846,   847,   850,
+     861,   868,   874,   878,   879,   882,   883,   886,   891,   898,
+     899,   900,   904,   908,   911,   912,   915,   916,   920,   921,
+     925,   926,   927,   931,   933,   934,   938,   939,   940,   941,
+     948,   949,   953,   954,   958,   959,   960,   963,   966,   967,
+     968,   969,   970,   971,   972,   973,   974,   975,   978,   984,
+     986,   992,   993
 };
 #endif
 
@@ -1018,25 +1018,25 @@ static const yytype_uint16 yyr1[] =
      199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
      199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
      199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
-     199,   200,   200,   201,   201,   201,   201,   202,   202,   203,
-     203,   204,   204,   204,   205,   205,   206,   206,   207,   208,
-     208,   209,   209,   210,   210,   210,   210,   210,   210,   210,
+     199,   199,   200,   200,   201,   201,   201,   201,   202,   202,
+     203,   203,   204,   204,   204,   205,   205,   206,   206,   207,
+     208,   208,   209,   209,   210,   210,   210,   210,   210,   210,
      210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
      210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
      210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
-     210,   210,   210,   211,   211,   212,   213,   214,   214,   215,
-     215,   216,   216,   217,   217,   218,   218,   219,   220,   221,
-     221,   222,   222,   223,   223,   223,   224,   224,   225,   225,
-     225,   225,   225,   225,   225,   225,   225,   225,   225,   226,
-     226,   227,   227,   227,   227,   227,   227,   227,   228,   228,
-     229,   230,   231,   231,   232,   233,   233,   234,   235,   235,
-     236,   236,   237,   237,   238,   238,   239,   239,   240,   241,
-     241,   241,   242,   242,   243,   243,   244,   245,   246,   246,
-     246,   247,   248,   249,   249,   250,   250,   251,   251,   252,
-     252,   252,   253,   253,   253,   254,   254,   254,   254,   255,
-     255,   256,   256,   257,   257,   257,   258,   259,   259,   259,
-     259,   259,   259,   259,   259,   259,   259,   260,   261,   261,
-     262,   262
+     210,   210,   210,   210,   211,   211,   212,   213,   214,   214,
+     215,   215,   216,   216,   217,   217,   218,   218,   219,   220,
+     221,   221,   222,   222,   223,   223,   223,   224,   224,   225,
+     225,   225,   225,   225,   225,   225,   225,   225,   225,   225,
+     226,   226,   227,   227,   227,   227,   227,   227,   227,   228,
+     228,   229,   230,   231,   231,   232,   233,   233,   234,   235,
+     235,   236,   236,   237,   237,   238,   238,   239,   239,   240,
+     241,   241,   241,   242,   242,   243,   243,   244,   245,   246,
+     246,   246,   247,   248,   249,   249,   250,   250,   251,   251,
+     252,   252,   252,   253,   253,   253,   254,   254,   254,   254,
+     255,   255,   256,   256,   257,   257,   257,   258,   259,   259,
+     259,   259,   259,   259,   259,   259,   259,   259,   260,   261,
+     261,   262,   262
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -1052,28 +1052,28 @@ static const yytype_uint8 yyr2[] =
        1,     1,     1,     1,     1,     4,     1,     1,     4,     1,
        4,     4,     1,     1,     4,     4,     4,     4,     4,     1,
        4,     1,     4,     1,     5,     1,     1,     4,     4,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     4,     1,
-       1,     1,     1,     6,     1,     1,     1,     1,     4,     1,
-       1,     1,     4,     4,     4,     4,     1,     1,     4,     4,
-       1,     1,     1,     1,     1,     1,     1,     0,     2,     4,
-       3,     0,     2,     1,     1,     3,     3,     1,     5,     1,
-       3,     0,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     5,     3,     3,     3,     3,     3,     3,     3,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     4,
+       1,     1,     1,     1,     6,     1,     1,     1,     1,     4,
+       1,     1,     1,     4,     4,     4,     4,     1,     1,     4,
+       4,     1,     1,     1,     1,     1,     1,     1,     0,     2,
+       4,     3,     0,     2,     1,     1,     3,     3,     1,     5,
+       1,     3,     0,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     5,     3,     3,     3,     3,     3,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     2,     2,     2,     2,     2,     2,     3,     3,     4,
-       4,     4,     3,     1,     3,     1,     1,     0,     2,     4,
-       3,     2,     2,     0,     2,     2,     1,     3,     3,     3,
-       2,     0,     1,     0,     1,     1,     1,     1,     1,     1,
-       1,     2,     2,     1,     1,     1,     1,     1,     1,     0,
-       1,     1,     2,     1,     2,     2,     1,     1,     2,     2,
-       2,     5,     0,     2,     2,     2,     2,     2,     2,     3,
-       2,     3,     5,     5,     0,     2,     2,     2,     2,     6,
-       8,     2,     2,     2,     2,     2,     2,     5,     1,     1,
-       1,     1,     1,     0,     2,     2,     3,     0,     1,     2,
-       2,     2,     3,     2,     1,     1,     3,     2,     4,     1,
-       3,     1,     3,     1,     1,     1,     5,     1,     1,     1,
-       1,     2,     1,     2,     1,     2,     4,     4,     5,    10,
-       1,     3
+       3,     3,     2,     2,     2,     2,     2,     2,     3,     3,
+       4,     4,     4,     3,     1,     3,     1,     1,     0,     2,
+       4,     3,     2,     2,     0,     2,     2,     1,     3,     3,
+       3,     2,     0,     1,     0,     1,     1,     1,     1,     1,
+       1,     1,     2,     2,     1,     1,     1,     1,     1,     1,
+       0,     1,     1,     2,     1,     2,     2,     1,     1,     2,
+       2,     2,     5,     0,     2,     2,     2,     2,     2,     2,
+       3,     2,     3,     5,     5,     0,     2,     2,     2,     2,
+       6,     8,     2,     2,     2,     2,     2,     2,     5,     1,
+       1,     1,     1,     1,     0,     2,     2,     3,     0,     1,
+       2,     2,     2,     3,     2,     1,     1,     3,     2,     4,
+       1,     3,     1,     3,     1,     1,     1,     5,     1,     1,
+       1,     1,     2,     1,     2,     1,     2,     4,     4,     5,
+      10,     1,     3
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -1081,61 +1081,61 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint16 yydefact[] =
 {
-       3,     0,     2,     1,   298,   226,   218,   237,     0,   272,
-       0,     0,   225,   213,   227,   268,   224,   228,   229,     0,
-     271,   231,   236,     0,   229,   270,     0,   229,     0,   233,
-     269,   213,    52,   213,   223,   297,   219,    60,    10,     0,
-      24,    11,    27,    11,     9,     0,   300,     0,   299,   220,
-       0,     0,     7,     0,     0,    22,     0,   254,     5,     4,
-       0,     8,   277,   277,   277,     0,     0,   302,   277,     0,
-     304,   238,   239,     0,   245,   246,   301,   215,     0,   230,
-     235,     0,   256,   257,   234,     0,   232,   221,   303,     0,
-       0,    53,   305,     0,   222,    61,    62,    63,    64,    65,
+       3,     0,     2,     1,   299,   227,   219,   238,     0,   273,
+       0,     0,   226,   214,   228,   269,   225,   229,   230,     0,
+     272,   232,   237,     0,   230,   271,     0,   230,     0,   234,
+     270,   214,    52,   214,   224,   298,   220,    60,    10,     0,
+      24,    11,    27,    11,     9,     0,   301,     0,   300,   221,
+       0,     0,     7,     0,     0,    22,     0,   255,     5,     4,
+       0,     8,   278,   278,   278,     0,     0,   303,   278,     0,
+     305,   239,   240,     0,   246,   247,   302,   216,     0,   231,
+     236,     0,   257,   258,   235,     0,   233,   222,   304,     0,
+       0,    53,   306,     0,   223,    61,    62,    63,    64,    65,
       66,     0,     0,    69,    70,    71,    72,    73,    74,     0,
       76,    77,     0,    79,     0,     0,    82,    83,     0,     0,
        0,     0,     0,    89,     0,    91,     0,    93,     0,    95,
-      96,     0,     0,    99,   100,   101,   102,   103,   104,   105,
-     106,   107,     0,   109,   110,   111,   295,   112,     0,   114,
-     293,   115,   116,   117,     0,   119,   120,   121,     0,     0,
-       0,   294,     0,   126,   127,     0,     0,     0,    55,   130,
-      25,     0,     0,     0,     0,     0,   300,   240,   247,   258,
-     266,     0,   302,   304,    26,     6,   242,   263,     0,    23,
-     261,   262,     0,     0,    20,   281,   278,   280,   279,   216,
-     217,   133,   134,   135,   136,   273,     0,     0,   285,   291,
-     284,   210,   300,   302,   277,   304,   275,    28,     0,   141,
-      36,     0,   197,     0,     0,   203,     0,     0,     0,     0,
+      96,    99,     0,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,     0,   110,   111,   112,   296,   113,     0,   115,
+     294,   116,   117,   118,     0,   120,   121,   122,     0,     0,
+       0,   295,     0,   127,   128,     0,     0,     0,    55,   131,
+      25,     0,     0,     0,     0,     0,   301,   241,   248,   259,
+     267,     0,   303,   305,    26,     6,   243,   264,     0,    23,
+     262,   263,     0,     0,    20,   282,   279,   281,   280,   217,
+     218,   134,   135,   136,   137,   274,     0,     0,   286,   292,
+     285,   211,   301,   303,   278,   305,   276,    28,     0,   142,
+      36,     0,   198,     0,     0,   204,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   151,     0,     0,   151,     0,     0,     0,     0,     0,
+       0,   152,     0,     0,   152,     0,     0,     0,     0,     0,
        0,    60,    54,    37,     0,    17,    18,    19,     0,    15,
-      13,    12,    16,    22,    39,   264,   265,    40,   209,    52,
-       0,    52,     0,     0,   255,    20,     0,     0,     0,   283,
-       0,   151,    42,   287,   276,    35,     0,   143,   144,   147,
-     306,    52,   289,   307,    52,    52,     0,   161,   153,   154,
-     155,   159,   160,   156,   157,     0,   158,     0,     0,     0,
-       0,     0,     0,     0,   195,     0,   193,   196,     0,     0,
+      13,    12,    16,    22,    39,   265,   266,    40,   210,    52,
+       0,    52,     0,     0,   256,    20,     0,     0,     0,   284,
+       0,   152,    42,   288,   277,    35,     0,   144,   145,   148,
+     307,    52,   290,   308,    52,    52,     0,   162,   154,   155,
+     156,   160,   161,   157,   158,     0,   159,     0,     0,     0,
+       0,     0,     0,     0,   196,     0,   194,   197,     0,     0,
       58,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   149,   152,     0,     0,     0,     0,     0,
-       0,   132,   131,     0,   310,     0,     0,    56,    60,     0,
-      14,    41,    22,     0,   243,   248,     0,     0,     0,    52,
-       0,     0,     0,    22,    21,     0,   274,   282,   286,   292,
-       0,     0,   297,     0,    47,    43,    45,     0,     0,   148,
-     142,     0,   296,     0,   198,     0,     0,   308,    53,   204,
-       0,    67,     0,   185,   184,   183,   186,   181,   182,     0,
+       0,     0,     0,   150,   153,     0,     0,     0,     0,     0,
+       0,   133,   132,     0,   311,     0,     0,    56,    60,     0,
+      14,    41,    22,     0,   244,   249,     0,     0,     0,    52,
+       0,     0,     0,    22,    21,     0,   275,   283,   287,   293,
+       0,     0,   298,     0,    47,    43,    45,     0,     0,   149,
+     143,     0,   297,     0,   199,     0,     0,   309,    53,   205,
+       0,    67,     0,   186,   185,   184,   187,   182,   183,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,    68,    75,    78,     0,    80,    81,
-      84,    85,    86,    87,    88,    90,    92,     0,    98,   151,
-      97,   108,     0,   118,   122,   123,   124,   125,     0,   128,
-     129,    57,     0,   241,   244,   250,     0,   249,   252,     0,
-       0,   253,    20,    22,   267,    51,    50,   288,     0,     0,
-      49,   145,   146,     0,   304,   290,   211,   202,   201,     0,
-     192,     0,   174,   175,   187,   168,   169,   172,   173,   163,
-     164,     0,   165,   166,   167,   171,   170,   177,   176,   179,
-     180,   178,   188,     0,   194,    59,    94,   150,     0,   311,
-      22,   207,     0,   251,     0,   259,    46,    48,     0,   200,
-       0,   212,   190,   189,     0,   191,   113,    38,   208,    22,
-     199,   137,   162,   260,     0,     0,     0,   309,   138,     0,
-      52,    52,   206,   140,     0,   139,   205
+      84,    85,    86,    87,    88,    90,    92,     0,    98,   152,
+      97,   109,     0,   119,   123,   124,   125,   126,     0,   129,
+     130,    57,     0,   242,   245,   251,     0,   250,   253,     0,
+       0,   254,    20,    22,   268,    51,    50,   289,     0,     0,
+      49,   146,   147,     0,   305,   291,   212,   203,   202,     0,
+     193,     0,   175,   176,   188,   169,   170,   173,   174,   164,
+     165,     0,   166,   167,   168,   172,   171,   178,   177,   180,
+     181,   179,   189,     0,   195,    59,    94,   151,     0,   312,
+      22,   208,     0,   252,     0,   260,    46,    48,     0,   201,
+       0,   213,   191,   190,     0,   192,   114,    38,   209,    22,
+     200,   138,   163,   261,     0,     0,     0,   310,   139,     0,
+      52,    52,   207,   141,     0,   140,   206
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
@@ -1232,17 +1232,17 @@ static const yytype_int16 yypgoto[] =
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -215
+#define YYTABLE_NINF -216
 static const yytype_int16 yytable[] =
 {
       45,   181,    70,    59,    46,    90,   351,   362,    67,   214,
       38,   323,   278,   279,   326,   179,   328,   371,   535,   331,
      289,   347,   336,   356,   322,    50,   358,   296,   221,   292,
-     536,   196,   196,   196,  -214,     9,   224,   196,   281,    11,
+     536,   196,   196,   196,  -215,     9,   224,   196,   281,    11,
      423,   282,     3,   403,   427,   183,   223,   176,   403,   386,
      390,   182,    73,   251,   146,    15,   439,   297,   150,   298,
      299,   300,   301,   302,   439,   424,   197,   198,   177,   428,
-      79,   216,   -44,   369,    23,   252,  -214,    20,   225,   385,
+      79,   216,   -44,   369,    23,   252,  -215,    20,   225,   385,
       23,   440,   161,   367,    84,    71,    72,    86,   297,   443,
      298,   299,   300,   301,   302,   453,    81,   -44,    37,   270,
       85,    37,   530,    37,   199,   200,   464,   352,   403,    25,
@@ -1254,7 +1254,7 @@ static const yytype_int16 yytable[] =
      472,   191,   -30,   202,   264,   401,   402,   403,   194,    45,
       45,    70,    70,    46,    46,   507,   305,    67,    67,   255,
      255,   289,   304,   196,   470,   418,   419,   420,   306,   339,
-     340,   475,  -214,   346,   514,   421,   422,   217,   219,   -31,
+     340,   475,  -215,   346,   514,   421,   422,   217,   219,   -31,
      421,   422,   504,   222,   203,   307,   515,   305,   308,   309,
      310,   226,   220,   311,   312,   317,   227,   284,   317,   306,
      228,   508,   465,   229,   313,   329,   230,   204,   334,   231,
@@ -3177,242 +3177,242 @@ yyreduce:
 
 /* Line 1455 of yacc.c  */
 #line 512 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_LOCAL); ;}
+    { (yyval.attr) = make_attr(ATTR_PARAMLCID); ;}
     break;
 
   case 100:
 
 /* Line 1455 of yacc.c  */
 #line 513 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;}
+    { (yyval.attr) = make_attr(ATTR_LOCAL); ;}
     break;
 
   case 101:
 
 /* Line 1455 of yacc.c  */
 #line 514 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;}
+    { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;}
     break;
 
   case 102:
 
 /* Line 1455 of yacc.c  */
 #line 515 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;}
+    { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;}
     break;
 
   case 103:
 
 /* Line 1455 of yacc.c  */
 #line 516 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OBJECT); ;}
+    { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;}
     break;
 
   case 104:
 
 /* Line 1455 of yacc.c  */
 #line 517 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_ODL); ;}
+    { (yyval.attr) = make_attr(ATTR_OBJECT); ;}
     break;
 
   case 105:
 
 /* Line 1455 of yacc.c  */
 #line 518 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;}
+    { (yyval.attr) = make_attr(ATTR_ODL); ;}
     break;
 
   case 106:
 
 /* Line 1455 of yacc.c  */
 #line 519 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;}
+    { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;}
     break;
 
   case 107:
 
 /* Line 1455 of yacc.c  */
 #line 520 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OUT); ;}
+    { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;}
     break;
 
   case 108:
 
 /* Line 1455 of yacc.c  */
 #line 521 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[(3) - (4)].num)); ;}
+    { (yyval.attr) = make_attr(ATTR_OUT); ;}
     break;
 
   case 109:
 
 /* Line 1455 of yacc.c  */
 #line 522 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_PROPGET); ;}
+    { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[(3) - (4)].num)); ;}
     break;
 
   case 110:
 
 /* Line 1455 of yacc.c  */
 #line 523 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_PROPPUT); ;}
+    { (yyval.attr) = make_attr(ATTR_PROPGET); ;}
     break;
 
   case 111:
 
 /* Line 1455 of yacc.c  */
 #line 524 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_PROPPUTREF); ;}
+    { (yyval.attr) = make_attr(ATTR_PROPPUT); ;}
     break;
 
   case 112:
 
 /* Line 1455 of yacc.c  */
 #line 525 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_PUBLIC); ;}
+    { (yyval.attr) = make_attr(ATTR_PROPPUTREF); ;}
     break;
 
   case 113:
 
 /* Line 1455 of yacc.c  */
-#line 527 "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); ;}
+#line 526 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_PUBLIC); ;}
     break;
 
   case 114:
 
 /* Line 1455 of yacc.c  */
-#line 530 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_READONLY); ;}
+#line 528 "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); ;}
     break;
 
   case 115:
 
 /* Line 1455 of yacc.c  */
 #line 531 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); ;}
+    { (yyval.attr) = make_attr(ATTR_READONLY); ;}
     break;
 
   case 116:
 
 /* Line 1455 of yacc.c  */
 #line 532 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_RESTRICTED); ;}
+    { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); ;}
     break;
 
   case 117:
 
 /* Line 1455 of yacc.c  */
 #line 533 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_RETVAL); ;}
+    { (yyval.attr) = make_attr(ATTR_RESTRICTED); ;}
     break;
 
   case 118:
 
 /* Line 1455 of yacc.c  */
 #line 534 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[(3) - (4)].expr_list)); ;}
+    { (yyval.attr) = make_attr(ATTR_RETVAL); ;}
     break;
 
   case 119:
 
 /* Line 1455 of yacc.c  */
 #line 535 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_SOURCE); ;}
+    { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[(3) - (4)].expr_list)); ;}
     break;
 
   case 120:
 
 /* Line 1455 of yacc.c  */
 #line 536 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); ;}
+    { (yyval.attr) = make_attr(ATTR_SOURCE); ;}
     break;
 
   case 121:
 
 /* Line 1455 of yacc.c  */
 #line 537 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_STRING); ;}
+    { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); ;}
     break;
 
   case 122:
 
 /* Line 1455 of yacc.c  */
 #line 538 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[(3) - (4)].expr)); ;}
+    { (yyval.attr) = make_attr(ATTR_STRING); ;}
     break;
 
   case 123:
 
 /* Line 1455 of yacc.c  */
 #line 539 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[(3) - (4)].type)); ;}
+    { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 124:
 
 /* Line 1455 of yacc.c  */
 #line 540 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[(3) - (4)].type)); ;}
+    { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 125:
 
 /* Line 1455 of yacc.c  */
 #line 541 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[(3) - (4)].uuid)); ;}
+    { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[(3) - (4)].type)); ;}
     break;
 
   case 126:
 
 /* Line 1455 of yacc.c  */
 #line 542 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_V1ENUM); ;}
+    { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[(3) - (4)].uuid)); ;}
     break;
 
   case 127:
 
 /* Line 1455 of yacc.c  */
 #line 543 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_VARARG); ;}
+    { (yyval.attr) = make_attr(ATTR_V1ENUM); ;}
     break;
 
   case 128:
 
 /* Line 1455 of yacc.c  */
 #line 544 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[(3) - (4)].num)); ;}
+    { (yyval.attr) = make_attr(ATTR_VARARG); ;}
     break;
 
   case 129:
 
 /* Line 1455 of yacc.c  */
 #line 545 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[(3) - (4)].type)); ;}
+    { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[(3) - (4)].num)); ;}
     break;
 
   case 130:
 
 /* Line 1455 of yacc.c  */
 #line 546 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[(1) - (1)].num)); ;}
+    { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[(3) - (4)].type)); ;}
     break;
 
-  case 132:
+  case 131:
 
 /* Line 1455 of yacc.c  */
-#line 551 "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)); ;}
+#line 547 "parser.y"
+    { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 133:
 
 /* Line 1455 of yacc.c  */
-#line 556 "parser.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
+#line 552 "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)); ;}
     break;
 
   case 134:
@@ -3439,65 +3439,72 @@ yyreduce:
   case 137:
 
 /* Line 1455 of yacc.c  */
-#line 562 "parser.y"
-    { (yyval.var_list) = NULL; ;}
+#line 560 "parser.y"
+    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 138:
 
 /* Line 1455 of yacc.c  */
 #line 563 "parser.y"
-    { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;}
+    { (yyval.var_list) = NULL; ;}
     break;
 
   case 139:
 
 /* Line 1455 of yacc.c  */
-#line 566 "parser.y"
+#line 564 "parser.y"
+    { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;}
+    break;
+
+  case 140:
+
+/* Line 1455 of yacc.c  */
+#line 567 "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 );
                                                ;}
     break;
 
-  case 140:
+  case 141:
 
 /* Line 1455 of yacc.c  */
-#line 570 "parser.y"
+#line 571 "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 );
                                                ;}
     break;
 
-  case 141:
+  case 142:
 
 /* Line 1455 of yacc.c  */
-#line 576 "parser.y"
+#line 577 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 142:
+  case 143:
 
 /* Line 1455 of yacc.c  */
-#line 577 "parser.y"
+#line 578 "parser.y"
     { (yyval.var_list) = (yyvsp[(1) - (2)].var_list); ;}
     break;
 
-  case 144:
+  case 145:
 
 /* Line 1455 of yacc.c  */
-#line 581 "parser.y"
+#line 582 "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) );
                                                ;}
     break;
 
-  case 145:
+  case 146:
 
 /* Line 1455 of yacc.c  */
-#line 585 "parser.y"
+#line 586 "parser.y"
     { if (!(yyvsp[(3) - (3)].var)->eval)
                                                   {
                                                     var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry );
@@ -3507,447 +3514,447 @@ yyreduce:
                                                ;}
     break;
 
-  case 146:
+  case 147:
 
 /* Line 1455 of yacc.c  */
-#line 594 "parser.y"
+#line 595 "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);
                                                ;}
     break;
 
-  case 147:
+  case 148:
 
 /* Line 1455 of yacc.c  */
-#line 598 "parser.y"
+#line 599 "parser.y"
     { (yyval.var) = reg_const((yyvsp[(1) - (1)].var));
                                                   (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0);
                                                ;}
     break;
 
-  case 148:
-
-/* Line 1455 of yacc.c  */
-#line 603 "parser.y"
-    { (yyval.type) = type_new_enum((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;}
-    break;
-
   case 149:
 
 /* Line 1455 of yacc.c  */
-#line 606 "parser.y"
-    { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
+#line 604 "parser.y"
+    { (yyval.type) = type_new_enum((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;}
     break;
 
   case 150:
 
 /* Line 1455 of yacc.c  */
 #line 607 "parser.y"
-    { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;}
+    { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
     break;
 
   case 151:
 
 /* Line 1455 of yacc.c  */
-#line 620 "parser.y"
-    { (yyval.expr) = make_expr(EXPR_VOID); ;}
+#line 608 "parser.y"
+    { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;}
     break;
 
-  case 153:
+  case 152:
 
 /* Line 1455 of yacc.c  */
-#line 624 "parser.y"
-    { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[(1) - (1)].num)); ;}
+#line 621 "parser.y"
+    { (yyval.expr) = make_expr(EXPR_VOID); ;}
     break;
 
   case 154:
 
 /* Line 1455 of yacc.c  */
 #line 625 "parser.y"
-    { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[(1) - (1)].num)); ;}
+    { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 155:
 
 /* Line 1455 of yacc.c  */
 #line 626 "parser.y"
-    { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[(1) - (1)].dbl)); ;}
+    { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[(1) - (1)].num)); ;}
     break;
 
   case 156:
 
 /* Line 1455 of yacc.c  */
 #line 627 "parser.y"
-    { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); ;}
+    { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[(1) - (1)].dbl)); ;}
     break;
 
   case 157:
 
 /* Line 1455 of yacc.c  */
 #line 628 "parser.y"
-    { (yyval.expr) = make_exprl(EXPR_NUM, 0); ;}
+    { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); ;}
     break;
 
   case 158:
 
 /* Line 1455 of yacc.c  */
 #line 629 "parser.y"
-    { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); ;}
+    { (yyval.expr) = make_exprl(EXPR_NUM, 0); ;}
     break;
 
   case 159:
 
 /* Line 1455 of yacc.c  */
 #line 630 "parser.y"
-    { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[(1) - (1)].str)); ;}
+    { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); ;}
     break;
 
   case 160:
 
 /* Line 1455 of yacc.c  */
 #line 631 "parser.y"
-    { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[(1) - (1)].str)); ;}
+    { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 161:
 
 /* Line 1455 of yacc.c  */
 #line 632 "parser.y"
-    { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[(1) - (1)].str)); ;}
+    { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 162:
 
 /* Line 1455 of yacc.c  */
 #line 633 "parser.y"
-    { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); ;}
+    { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 163:
 
 /* Line 1455 of yacc.c  */
 #line 634 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); ;}
     break;
 
   case 164:
 
 /* Line 1455 of yacc.c  */
 #line 635 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 165:
 
 /* Line 1455 of yacc.c  */
 #line 636 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 166:
 
 /* Line 1455 of yacc.c  */
 #line 637 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 167:
 
 /* Line 1455 of yacc.c  */
 #line 638 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 168:
 
 /* Line 1455 of yacc.c  */
 #line 639 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 169:
 
 /* Line 1455 of yacc.c  */
 #line 640 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 170:
 
 /* Line 1455 of yacc.c  */
 #line 641 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 171:
 
 /* Line 1455 of yacc.c  */
 #line 642 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 172:
 
 /* Line 1455 of yacc.c  */
 #line 643 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 173:
 
 /* Line 1455 of yacc.c  */
 #line 644 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 174:
 
 /* Line 1455 of yacc.c  */
 #line 645 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 175:
 
 /* Line 1455 of yacc.c  */
 #line 646 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 176:
 
 /* Line 1455 of yacc.c  */
 #line 647 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 177:
 
 /* Line 1455 of yacc.c  */
 #line 648 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 178:
 
 /* Line 1455 of yacc.c  */
 #line 649 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 179:
 
 /* Line 1455 of yacc.c  */
 #line 650 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 180:
 
 /* Line 1455 of yacc.c  */
 #line 651 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 181:
 
 /* Line 1455 of yacc.c  */
 #line 652 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 182:
 
 /* Line 1455 of yacc.c  */
 #line 653 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 183:
 
 /* Line 1455 of yacc.c  */
 #line 654 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 184:
 
 /* Line 1455 of yacc.c  */
 #line 655 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 185:
 
 /* Line 1455 of yacc.c  */
 #line 656 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 186:
 
 /* Line 1455 of yacc.c  */
 #line 657 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 187:
 
 /* Line 1455 of yacc.c  */
 #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))); ;}
+    { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 188:
 
 /* Line 1455 of yacc.c  */
 #line 659 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[(1) - (3)].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); ;}
+    { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[(1) - (3)].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); ;}
     break;
 
   case 189:
 
 /* Line 1455 of yacc.c  */
 #line 660 "parser.y"
-    { (yyval.expr) = make_exprt(EXPR_CAST, (yyvsp[(2) - (4)].type), (yyvsp[(4) - (4)].expr)); ;}
+    { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[(1) - (3)].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); ;}
     break;
 
   case 190:
 
 /* Line 1455 of yacc.c  */
 #line 661 "parser.y"
-    { (yyval.expr) = make_exprt(EXPR_SIZEOF, (yyvsp[(3) - (4)].type), NULL); ;}
+    { (yyval.expr) = make_exprt(EXPR_CAST, (yyvsp[(2) - (4)].type), (yyvsp[(4) - (4)].expr)); ;}
     break;
 
   case 191:
 
 /* Line 1455 of yacc.c  */
 #line 662 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); ;}
+    { (yyval.expr) = make_exprt(EXPR_SIZEOF, (yyvsp[(3) - (4)].type), NULL); ;}
     break;
 
   case 192:
 
 /* Line 1455 of yacc.c  */
 #line 663 "parser.y"
-    { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
+    { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); ;}
     break;
 
   case 193:
 
 /* Line 1455 of yacc.c  */
-#line 666 "parser.y"
-    { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
+#line 664 "parser.y"
+    { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
     break;
 
   case 194:
 
 /* Line 1455 of yacc.c  */
 #line 667 "parser.y"
-    { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;}
+    { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;}
     break;
 
   case 195:
 
 /* Line 1455 of yacc.c  */
-#line 670 "parser.y"
+#line 668 "parser.y"
+    { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;}
+    break;
+
+  case 196:
+
+/* Line 1455 of yacc.c  */
+#line 671 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);
                                                  if (!(yyval.expr)->is_const)
                                                      error_loc("expression is not an integer constant\n");
                                                ;}
     break;
 
-  case 196:
+  case 197:
 
 /* Line 1455 of yacc.c  */
-#line 676 "parser.y"
+#line 677 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);
                                                  if (!(yyval.expr)->is_const && (yyval.expr)->type != EXPR_STRLIT && (yyval.expr)->type != EXPR_WSTRLIT)
                                                      error_loc("expression is not constant\n");
                                                ;}
     break;
 
-  case 197:
+  case 198:
 
 /* Line 1455 of yacc.c  */
-#line 682 "parser.y"
+#line 683 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 198:
+  case 199:
 
 /* Line 1455 of yacc.c  */
-#line 683 "parser.y"
+#line 684 "parser.y"
     { (yyval.var_list) = append_var_list((yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var_list)); ;}
     break;
 
-  case 199:
+  case 200:
 
 /* Line 1455 of yacc.c  */
-#line 687 "parser.y"
+#line 688 "parser.y"
     { const char *first = LIST_ENTRY(list_head((yyvsp[(3) - (4)].declarator_list)), declarator_t, entry)->var->name;
                                                  check_field_attrs(first, (yyvsp[(1) - (4)].attr_list));
                                                  (yyval.var_list) = set_var_types((yyvsp[(1) - (4)].attr_list), (yyvsp[(2) - (4)].declspec), (yyvsp[(3) - (4)].declarator_list));
                                                ;}
     break;
 
-  case 200:
+  case 201:
 
 /* Line 1455 of yacc.c  */
-#line 691 "parser.y"
+#line 692 "parser.y"
     { var_t *v = make_var(NULL);
                                                  v->type = (yyvsp[(2) - (3)].type); v->attrs = (yyvsp[(1) - (3)].attr_list);
                                                  (yyval.var_list) = append_var(NULL, v);
                                                ;}
     break;
 
-  case 201:
+  case 202:
 
 /* Line 1455 of yacc.c  */
-#line 698 "parser.y"
+#line 699 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (2)].var); ;}
     break;
 
-  case 202:
+  case 203:
 
 /* Line 1455 of yacc.c  */
-#line 699 "parser.y"
+#line 700 "parser.y"
     { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[(1) - (2)].attr_list); ;}
     break;
 
-  case 203:
+  case 204:
 
 /* Line 1455 of yacc.c  */
-#line 702 "parser.y"
+#line 703 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 204:
+  case 205:
 
 /* Line 1455 of yacc.c  */
-#line 703 "parser.y"
+#line 704 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;}
     break;
 
-  case 205:
+  case 206:
 
 /* Line 1455 of yacc.c  */
-#line 707 "parser.y"
+#line 708 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (2)].var); ;}
     break;
 
-  case 206:
+  case 207:
 
 /* Line 1455 of yacc.c  */
-#line 708 "parser.y"
+#line 709 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
-  case 207:
+  case 208:
 
 /* Line 1455 of yacc.c  */
-#line 711 "parser.y"
+#line 712 "parser.y"
     { (yyval.var) = (yyvsp[(3) - (3)].declarator)->var;
                                                  (yyval.var)->attrs = check_field_attrs((yyval.var)->name, (yyvsp[(1) - (3)].attr_list));
                                                  set_type((yyval.var), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE);
@@ -3955,10 +3962,10 @@ yyreduce:
                                                ;}
     break;
 
-  case 208:
+  case 209:
 
 /* Line 1455 of yacc.c  */
-#line 719 "parser.y"
+#line 720 "parser.y"
     { var_t *v = (yyvsp[(3) - (3)].declarator)->var;
                                                  v->attrs = check_function_attrs(v->name, (yyvsp[(1) - (3)].attr_list));
                                                  set_type(v, (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE);
@@ -3967,10 +3974,10 @@ yyreduce:
                                                ;}
     break;
 
-  case 209:
+  case 210:
 
 /* Line 1455 of yacc.c  */
-#line 729 "parser.y"
+#line 730 "parser.y"
     { (yyval.var) = (yyvsp[(3) - (3)].declarator)->var;
                                                  (yyval.var)->attrs = (yyvsp[(1) - (3)].attr_list);
                                                  set_type((yyval.var), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE);
@@ -3978,35 +3985,28 @@ yyreduce:
                                                ;}
     break;
 
-  case 210:
+  case 211:
 
 /* Line 1455 of yacc.c  */
-#line 734 "parser.y"
+#line 735 "parser.y"
     { (yyval.var) = (yyvsp[(2) - (2)].declarator)->var;
                                                  set_type((yyval.var), (yyvsp[(1) - (2)].declspec), (yyvsp[(2) - (2)].declarator), FALSE);
                                                  free((yyvsp[(2) - (2)].declarator));
                                                ;}
     break;
 
-  case 211:
+  case 212:
 
 /* Line 1455 of yacc.c  */
-#line 740 "parser.y"
+#line 741 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
-  case 213:
-
-/* Line 1455 of yacc.c  */
-#line 744 "parser.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
   case 214:
 
 /* Line 1455 of yacc.c  */
 #line 745 "parser.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
+    { (yyval.str) = NULL; ;}
     break;
 
   case 215:
@@ -4019,22 +4019,22 @@ yyreduce:
   case 216:
 
 /* Line 1455 of yacc.c  */
-#line 749 "parser.y"
-    { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
+#line 747 "parser.y"
+    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
     break;
 
   case 217:
 
 /* Line 1455 of yacc.c  */
-#line 751 "parser.y"
+#line 750 "parser.y"
     { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 218:
 
 /* Line 1455 of yacc.c  */
-#line 754 "parser.y"
-    { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
+#line 752 "parser.y"
+    { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 219:
@@ -4044,32 +4044,32 @@ yyreduce:
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
-  case 221:
+  case 220:
 
 /* Line 1455 of yacc.c  */
-#line 757 "parser.y"
-    { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[(2) - (2)].type)), -1); ;}
+#line 756 "parser.y"
+    { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 222:
 
 /* Line 1455 of yacc.c  */
 #line 758 "parser.y"
-    { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[(2) - (2)].type)), 1); ;}
+    { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[(2) - (2)].type)), -1); ;}
     break;
 
   case 223:
 
 /* Line 1455 of yacc.c  */
 #line 759 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); ;}
+    { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[(2) - (2)].type)), 1); ;}
     break;
 
   case 224:
 
 /* Line 1455 of yacc.c  */
 #line 760 "parser.y"
-    { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); ;}
     break;
 
   case 225:
@@ -4100,66 +4100,73 @@ yyreduce:
     { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
-  case 231:
+  case 229:
 
 /* Line 1455 of yacc.c  */
-#line 771 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); ;}
+#line 765 "parser.y"
+    { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 232:
 
 /* Line 1455 of yacc.c  */
 #line 772 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); ;}
     break;
 
   case 233:
 
 /* Line 1455 of yacc.c  */
 #line 773 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); ;}
     break;
 
   case 234:
 
 /* Line 1455 of yacc.c  */
 #line 774 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); ;}
     break;
 
   case 235:
 
 /* Line 1455 of yacc.c  */
 #line 775 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); ;}
     break;
 
   case 236:
 
 /* Line 1455 of yacc.c  */
 #line 776 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); ;}
     break;
 
   case 237:
 
 /* Line 1455 of yacc.c  */
 #line 777 "parser.y"
-    { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); ;}
+    { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); ;}
     break;
 
   case 238:
 
 /* Line 1455 of yacc.c  */
-#line 780 "parser.y"
-    { (yyval.type) = type_new_coclass((yyvsp[(2) - (2)].str)); ;}
+#line 778 "parser.y"
+    { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); ;}
     break;
 
   case 239:
 
 /* Line 1455 of yacc.c  */
 #line 781 "parser.y"
+    { (yyval.type) = type_new_coclass((yyvsp[(2) - (2)].str)); ;}
+    break;
+
+  case 240:
+
+/* Line 1455 of yacc.c  */
+#line 782 "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",
@@ -4168,62 +4175,62 @@ yyreduce:
                                                ;}
     break;
 
-  case 240:
+  case 241:
 
 /* Line 1455 of yacc.c  */
-#line 789 "parser.y"
+#line 790 "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));
                                                ;}
     break;
 
-  case 241:
+  case 242:
 
 /* Line 1455 of yacc.c  */
-#line 796 "parser.y"
+#line 797 "parser.y"
     { (yyval.type) = type_coclass_define((yyvsp[(1) - (5)].type), (yyvsp[(3) - (5)].ifref_list)); ;}
     break;
 
-  case 242:
+  case 243:
 
 /* Line 1455 of yacc.c  */
-#line 799 "parser.y"
+#line 800 "parser.y"
     { (yyval.ifref_list) = NULL; ;}
     break;
 
-  case 243:
+  case 244:
 
 /* Line 1455 of yacc.c  */
-#line 800 "parser.y"
+#line 801 "parser.y"
     { (yyval.ifref_list) = append_ifref( (yyvsp[(1) - (2)].ifref_list), (yyvsp[(2) - (2)].ifref) ); ;}
     break;
 
-  case 244:
+  case 245:
 
 /* Line 1455 of yacc.c  */
-#line 804 "parser.y"
+#line 805 "parser.y"
     { (yyval.ifref) = make_ifref((yyvsp[(2) - (2)].type)); (yyval.ifref)->attrs = (yyvsp[(1) - (2)].attr_list); ;}
     break;
 
-  case 245:
+  case 246:
 
 /* Line 1455 of yacc.c  */
-#line 807 "parser.y"
+#line 808 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
-  case 246:
+  case 247:
 
 /* Line 1455 of yacc.c  */
-#line 808 "parser.y"
+#line 809 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
-  case 247:
+  case 248:
 
 /* Line 1455 of yacc.c  */
-#line 811 "parser.y"
+#line 812 "parser.y"
     { attr_t *attrs;
                                                  is_object_interface = TRUE;
                                                  (yyval.type) = (yyvsp[(2) - (2)].type);
@@ -4234,84 +4241,84 @@ yyreduce:
                                                ;}
     break;
 
-  case 248:
+  case 249:
 
 /* Line 1455 of yacc.c  */
-#line 821 "parser.y"
+#line 822 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 249:
+  case 250:
 
 /* Line 1455 of yacc.c  */
-#line 822 "parser.y"
+#line 823 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); ;}
     break;
 
-  case 250:
+  case 251:
 
 /* Line 1455 of yacc.c  */
-#line 825 "parser.y"
+#line 826 "parser.y"
     { (yyval.stmt_list) = NULL; ;}
     break;
 
-  case 251:
+  case 252:
 
 /* Line 1455 of yacc.c  */
-#line 826 "parser.y"
+#line 827 "parser.y"
     { (yyval.stmt_list) = append_func( (yyvsp[(1) - (3)].stmt_list), (yyvsp[(2) - (3)].func) ); ;}
     break;
 
-  case 252:
+  case 253:
 
 /* Line 1455 of yacc.c  */
-#line 832 "parser.y"
+#line 833 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                  type_dispinterface_define((yyval.type), (yyvsp[(3) - (5)].var_list), (yyvsp[(4) - (5)].stmt_list));
                                                ;}
     break;
 
-  case 253:
+  case 254:
 
 /* Line 1455 of yacc.c  */
-#line 836 "parser.y"
+#line 837 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (5)].type);
                                                  type_dispinterface_define_from_iface((yyval.type), (yyvsp[(3) - (5)].type));
                                                ;}
     break;
 
-  case 254:
+  case 255:
 
 /* Line 1455 of yacc.c  */
-#line 841 "parser.y"
+#line 842 "parser.y"
     { (yyval.type) = NULL; ;}
     break;
 
-  case 255:
+  case 256:
 
 /* Line 1455 of yacc.c  */
-#line 842 "parser.y"
+#line 843 "parser.y"
     { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); ;}
     break;
 
-  case 256:
+  case 257:
 
 /* Line 1455 of yacc.c  */
-#line 845 "parser.y"
+#line 846 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
-  case 257:
+  case 258:
 
 /* Line 1455 of yacc.c  */
-#line 846 "parser.y"
+#line 847 "parser.y"
     { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;}
     break;
 
-  case 258:
+  case 259:
 
 /* Line 1455 of yacc.c  */
-#line 849 "parser.y"
+#line 850 "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))
@@ -4323,37 +4330,30 @@ yyreduce:
                                                ;}
     break;
 
-  case 259:
+  case 260:
 
 /* Line 1455 of yacc.c  */
-#line 861 "parser.y"
+#line 862 "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;
                                                ;}
     break;
 
-  case 260:
+  case 261:
 
 /* Line 1455 of yacc.c  */
-#line 869 "parser.y"
+#line 870 "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;
                                                ;}
     break;
 
-  case 261:
-
-/* Line 1455 of yacc.c  */
-#line 873 "parser.y"
-    { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
-    break;
-
   case 262:
 
 /* Line 1455 of yacc.c  */
-#line 877 "parser.y"
+#line 874 "parser.y"
     { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
@@ -4367,8 +4367,8 @@ yyreduce:
   case 264:
 
 /* Line 1455 of yacc.c  */
-#line 881 "parser.y"
-    { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;}
+#line 879 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (2)].type); ;}
     break;
 
   case 265:
@@ -4381,96 +4381,96 @@ yyreduce:
   case 266:
 
 /* Line 1455 of yacc.c  */
-#line 885 "parser.y"
-    { (yyval.type) = (yyvsp[(2) - (2)].type);
-                                                 (yyval.type)->attrs = check_module_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list));
-                                               ;}
+#line 883 "parser.y"
+    { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 267:
 
 /* Line 1455 of yacc.c  */
-#line 891 "parser.y"
-    { (yyval.type) = (yyvsp[(1) - (5)].type);
-                                                  type_module_define((yyval.type), (yyvsp[(3) - (5)].stmt_list));
+#line 886 "parser.y"
+    { (yyval.type) = (yyvsp[(2) - (2)].type);
+                                                 (yyval.type)->attrs = check_module_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list));
                                                ;}
     break;
 
   case 268:
 
 /* Line 1455 of yacc.c  */
-#line 897 "parser.y"
-    { (yyval.stgclass) = STG_EXTERN; ;}
+#line 892 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (5)].type);
+                                                  type_module_define((yyval.type), (yyvsp[(3) - (5)].stmt_list));
+                                               ;}
     break;
 
   case 269:
 
 /* Line 1455 of yacc.c  */
 #line 898 "parser.y"
-    { (yyval.stgclass) = STG_STATIC; ;}
+    { (yyval.stgclass) = STG_EXTERN; ;}
     break;
 
   case 270:
 
 /* Line 1455 of yacc.c  */
 #line 899 "parser.y"
-    { (yyval.stgclass) = STG_REGISTER; ;}
+    { (yyval.stgclass) = STG_STATIC; ;}
     break;
 
   case 271:
 
 /* Line 1455 of yacc.c  */
-#line 903 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_INLINE); ;}
+#line 900 "parser.y"
+    { (yyval.stgclass) = STG_REGISTER; ;}
     break;
 
   case 272:
 
 /* Line 1455 of yacc.c  */
-#line 907 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_CONST); ;}
+#line 904 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_INLINE); ;}
     break;
 
   case 273:
 
 /* Line 1455 of yacc.c  */
-#line 910 "parser.y"
-    { (yyval.attr_list) = NULL; ;}
+#line 908 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_CONST); ;}
     break;
 
   case 274:
 
 /* Line 1455 of yacc.c  */
 #line 911 "parser.y"
-    { (yyval.attr_list) = append_attr((yyvsp[(1) - (2)].attr_list), (yyvsp[(2) - (2)].attr)); ;}
+    { (yyval.attr_list) = NULL; ;}
     break;
 
   case 275:
 
 /* Line 1455 of yacc.c  */
-#line 914 "parser.y"
-    { (yyval.declspec) = make_decl_spec((yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].declspec), NULL, NULL, STG_NONE); ;}
+#line 912 "parser.y"
+    { (yyval.attr_list) = append_attr((yyvsp[(1) - (2)].attr_list), (yyvsp[(2) - (2)].attr)); ;}
     break;
 
   case 276:
 
 /* Line 1455 of yacc.c  */
-#line 916 "parser.y"
-    { (yyval.declspec) = make_decl_spec((yyvsp[(2) - (3)].type), (yyvsp[(1) - (3)].declspec), (yyvsp[(3) - (3)].declspec), NULL, STG_NONE); ;}
+#line 915 "parser.y"
+    { (yyval.declspec) = make_decl_spec((yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].declspec), NULL, NULL, STG_NONE); ;}
     break;
 
   case 277:
 
 /* Line 1455 of yacc.c  */
-#line 919 "parser.y"
-    { (yyval.declspec) = NULL; ;}
+#line 917 "parser.y"
+    { (yyval.declspec) = make_decl_spec((yyvsp[(2) - (3)].type), (yyvsp[(1) - (3)].declspec), (yyvsp[(3) - (3)].declspec), NULL, STG_NONE); ;}
     break;
 
-  case 279:
+  case 278:
 
 /* Line 1455 of yacc.c  */
-#line 924 "parser.y"
-    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); ;}
+#line 920 "parser.y"
+    { (yyval.declspec) = NULL; ;}
     break;
 
   case 280:
@@ -4484,129 +4484,129 @@ yyreduce:
 
 /* Line 1455 of yacc.c  */
 #line 926 "parser.y"
-    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, NULL, (yyvsp[(1) - (2)].stgclass)); ;}
+    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); ;}
     break;
 
   case 282:
 
 /* Line 1455 of yacc.c  */
-#line 931 "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))); ;}
+#line 927 "parser.y"
+    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, NULL, (yyvsp[(1) - (2)].stgclass)); ;}
     break;
 
   case 283:
 
 /* Line 1455 of yacc.c  */
 #line 932 "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))); ;}
+    { (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 285:
+  case 284:
 
 /* Line 1455 of yacc.c  */
-#line 937 "parser.y"
-    { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); ;}
+#line 933 "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 286:
 
 /* Line 1455 of yacc.c  */
 #line 938 "parser.y"
-    { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;}
+    { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); ;}
     break;
 
   case 287:
 
 /* Line 1455 of yacc.c  */
 #line 939 "parser.y"
-    { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); ;}
+    { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;}
     break;
 
   case 288:
 
 /* Line 1455 of yacc.c  */
 #line 940 "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;
-                                               ;}
+    { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); ;}
     break;
 
   case 289:
 
 /* Line 1455 of yacc.c  */
-#line 947 "parser.y"
-    { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[(1) - (1)].declarator) ); ;}
+#line 941 "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;
+                                               ;}
     break;
 
   case 290:
 
 /* Line 1455 of yacc.c  */
 #line 948 "parser.y"
-    { (yyval.declarator_list) = append_declarator( (yyvsp[(1) - (3)].declarator_list), (yyvsp[(3) - (3)].declarator) ); ;}
+    { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[(1) - (1)].declarator) ); ;}
     break;
 
   case 291:
 
 /* Line 1455 of yacc.c  */
-#line 952 "parser.y"
-    { (yyval.declarator) = (yyvsp[(1) - (1)].declarator); ;}
+#line 949 "parser.y"
+    { (yyval.declarator_list) = append_declarator( (yyvsp[(1) - (3)].declarator_list), (yyvsp[(3) - (3)].declarator) ); ;}
     break;
 
   case 292:
 
 /* Line 1455 of yacc.c  */
 #line 953 "parser.y"
-    { (yyval.declarator) = (yyvsp[(1) - (3)].declarator); (yyvsp[(1) - (3)].declarator)->var->eval = (yyvsp[(3) - (3)].expr); ;}
+    { (yyval.declarator) = (yyvsp[(1) - (1)].declarator); ;}
     break;
 
   case 293:
 
 /* Line 1455 of yacc.c  */
-#line 957 "parser.y"
-    { (yyval.num) = RPC_FC_RP; ;}
+#line 954 "parser.y"
+    { (yyval.declarator) = (yyvsp[(1) - (3)].declarator); (yyvsp[(1) - (3)].declarator)->var->eval = (yyvsp[(3) - (3)].expr); ;}
     break;
 
   case 294:
 
 /* Line 1455 of yacc.c  */
 #line 958 "parser.y"
-    { (yyval.num) = RPC_FC_UP; ;}
+    { (yyval.num) = RPC_FC_RP; ;}
     break;
 
   case 295:
 
 /* Line 1455 of yacc.c  */
 #line 959 "parser.y"
-    { (yyval.num) = RPC_FC_FP; ;}
+    { (yyval.num) = RPC_FC_UP; ;}
     break;
 
   case 296:
 
 /* Line 1455 of yacc.c  */
-#line 962 "parser.y"
-    { (yyval.type) = type_new_struct((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;}
+#line 960 "parser.y"
+    { (yyval.num) = RPC_FC_FP; ;}
     break;
 
   case 297:
 
 /* Line 1455 of yacc.c  */
-#line 965 "parser.y"
-    { (yyval.type) = type_new_void(); ;}
+#line 963 "parser.y"
+    { (yyval.type) = type_new_struct((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;}
     break;
 
   case 298:
 
 /* Line 1455 of yacc.c  */
 #line 966 "parser.y"
-    { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
+    { (yyval.type) = type_new_void(); ;}
     break;
 
   case 299:
 
 /* Line 1455 of yacc.c  */
 #line 967 "parser.y"
-    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;}
     break;
 
   case 300:
@@ -4620,85 +4620,92 @@ yyreduce:
 
 /* Line 1455 of yacc.c  */
 #line 969 "parser.y"
-    { (yyval.type) = type_new_enum((yyvsp[(2) - (2)].str), FALSE, NULL); ;}
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
     break;
 
   case 302:
 
 /* Line 1455 of yacc.c  */
 #line 970 "parser.y"
-    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    { (yyval.type) = type_new_enum((yyvsp[(2) - (2)].str), FALSE, NULL); ;}
     break;
 
   case 303:
 
 /* Line 1455 of yacc.c  */
 #line 971 "parser.y"
-    { (yyval.type) = type_new_struct((yyvsp[(2) - (2)].str), FALSE, NULL); ;}
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
     break;
 
   case 304:
 
 /* Line 1455 of yacc.c  */
 #line 972 "parser.y"
-    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    { (yyval.type) = type_new_struct((yyvsp[(2) - (2)].str), FALSE, NULL); ;}
     break;
 
   case 305:
 
 /* Line 1455 of yacc.c  */
 #line 973 "parser.y"
-    { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (2)].str), FALSE, NULL); ;}
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
     break;
 
   case 306:
 
 /* Line 1455 of yacc.c  */
 #line 974 "parser.y"
-    { (yyval.type) = make_safearray((yyvsp[(3) - (4)].type)); ;}
+    { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (2)].str), FALSE, NULL); ;}
     break;
 
   case 307:
 
 /* Line 1455 of yacc.c  */
-#line 978 "parser.y"
+#line 975 "parser.y"
+    { (yyval.type) = make_safearray((yyvsp[(3) - (4)].type)); ;}
+    break;
+
+  case 308:
+
+/* Line 1455 of yacc.c  */
+#line 979 "parser.y"
     { reg_typedefs((yyvsp[(3) - (4)].declspec), (yyvsp[(4) - (4)].declarator_list), check_typedef_attrs((yyvsp[(2) - (4)].attr_list)));
                                                  (yyval.statement) = make_statement_typedef((yyvsp[(4) - (4)].declarator_list));
                                                ;}
     break;
 
-  case 308:
+  case 309:
 
 /* Line 1455 of yacc.c  */
-#line 984 "parser.y"
+#line 985 "parser.y"
     { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;}
     break;
 
-  case 309:
+  case 310:
 
 /* Line 1455 of yacc.c  */
-#line 987 "parser.y"
+#line 988 "parser.y"
     { (yyval.type) = type_new_encapsulated_union((yyvsp[(2) - (10)].str), (yyvsp[(5) - (10)].var), (yyvsp[(7) - (10)].var), (yyvsp[(9) - (10)].var_list)); ;}
     break;
 
-  case 310:
+  case 311:
 
 /* Line 1455 of yacc.c  */
-#line 991 "parser.y"
+#line 992 "parser.y"
     { (yyval.num) = MAKEVERSION((yyvsp[(1) - (1)].num), 0); ;}
     break;
 
-  case 311:
+  case 312:
 
 /* Line 1455 of yacc.c  */
-#line 992 "parser.y"
+#line 993 "parser.y"
     { (yyval.num) = MAKEVERSION((yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num)); ;}
     break;
 
 
 
 /* Line 1455 of yacc.c  */
-#line 4702 "parser.tab.c"
+#line 4709 "parser.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -4910,7 +4917,7 @@ yyreturn:
 
 
 /* Line 1675 of yacc.c  */
-#line 995 "parser.y"
+#line 996 "parser.y"
 
 
 static void decl_builtin_basic(const char *name, enum type_basic_type type)
@@ -5838,6 +5845,7 @@ struct allowed_attr allowed_attr[] =
     /* ATTR_OLEAUTOMATION */       { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
     /* ATTR_OPTIONAL */            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
     /* ATTR_OUT */                 { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
+    /* ATTR_PARAMLCID */           { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
     /* ATTR_POINTERDEFAULT */      { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
     /* ATTR_POINTERTYPE */         { 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
     /* ATTR_PROPGET */             { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
index 7fe373c..c2f1abc 100644 (file)
@@ -509,6 +509,7 @@ attribute:                                  { $$ = NULL; }
        | tINPUTSYNC                            { $$ = make_attr(ATTR_INPUTSYNC); }
        | tLENGTHIS '(' m_exprs ')'             { $$ = make_attrp(ATTR_LENGTHIS, $3); }
        | tLCID '(' expr_int_const ')'          { $$ = make_attrp(ATTR_LIBLCID, $3); }
+       | tLCID                                 { $$ = make_attr(ATTR_PARAMLCID); }
        | tLOCAL                                { $$ = make_attr(ATTR_LOCAL); }
        | tNONBROWSABLE                         { $$ = make_attr(ATTR_NONBROWSABLE); }
        | tNONCREATABLE                         { $$ = make_attr(ATTR_NONCREATABLE); }
@@ -1919,6 +1920,7 @@ struct allowed_attr allowed_attr[] =
     /* ATTR_OLEAUTOMATION */       { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
     /* ATTR_OPTIONAL */            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
     /* ATTR_OUT */                 { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
+    /* ATTR_PARAMLCID */           { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
     /* ATTR_POINTERDEFAULT */      { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
     /* ATTR_POINTERTYPE */         { 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
     /* ATTR_PROPGET */             { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
index b8ccdac..cc753bb 100644 (file)
@@ -624,7 +624,8 @@ static void write_proxy(type_t *iface, unsigned int *proc_offset)
   count = count_methods(iface);
 
   /* proxy vtable */
-  print_proxy( "static const CINTERFACE_PROXY_VTABLE(%d) _%sProxyVtbl =\n", count, iface->name);
+  print_proxy( "static %sCINTERFACE_PROXY_VTABLE(%d) _%sProxyVtbl =\n",
+               need_delegation_indirect(iface) ? "" : "const ", count, iface->name);
   print_proxy( "{\n");
   indent++;
   print_proxy( "{\n");
index 1b7c79d..b820430 100644 (file)
@@ -59,6 +59,7 @@ struct expr_eval_routine
     const expr_t *expr;
 };
 
+static unsigned int field_memsize(const type_t *type, unsigned int *offset);
 static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align);
 static unsigned int write_struct_tfs(FILE *file, type_t *type, const char *name, unsigned int *tfsoff);
 static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
@@ -978,14 +979,13 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *structure,
 
         if (fields) LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry )
         {
-            unsigned int align = 0;
-            /* FIXME: take alignment into account */
+            unsigned int size = field_memsize( var->type, &offset );
             if (var->name && !strcmp(var->name, subexpr->u.sval))
             {
                 correlation_variable = var->type;
                 break;
             }
-            offset += type_memsize(var->type, &align);
+            offset += size;
         }
         if (!correlation_variable)
             error("write_conf_or_var_desc: couldn't find variable %s in structure\n",
@@ -1081,9 +1081,18 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *structure,
     return 4;
 }
 
+/* return size and start offset of a data field based on current offset */
+static unsigned int field_memsize(const type_t *type, unsigned int *offset)
+{
+    unsigned int align = 0;
+    unsigned int size = type_memsize( type, &align );
+
+    *offset = ROUND_SIZE( *offset, align );
+    return size;
+}
+
 static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align)
 {
-    int have_align = FALSE;
     unsigned int size = 0;
     const var_t *v;
 
@@ -1092,11 +1101,7 @@ static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align
     {
         unsigned int falign = 0;
         unsigned int fsize = type_memsize(v->type, &falign);
-        if (!have_align)
-        {
-            *align = falign;
-            have_align = TRUE;
-        }
+        if (*align < falign) *align = falign;
         size = ROUND_SIZE(size, falign);
         size += fsize;
     }
@@ -1128,7 +1133,7 @@ static unsigned int union_memsize(const var_list_t *fields, unsigned int *pmaxa)
 int get_padding(const var_list_t *fields)
 {
     unsigned short offset = 0;
-    int salign = -1;
+    unsigned int salign = 1;
     const var_t *f;
 
     if (!fields)
@@ -1139,8 +1144,7 @@ int get_padding(const var_list_t *fields)
         type_t *ft = f->type;
         unsigned int align = 0;
         unsigned int size = type_memsize(ft, &align);
-        if (salign == -1)
-            salign = align;
+        if (align > salign) salign = align;
         offset = ROUND_SIZE(offset, align);
         offset += size;
     }
@@ -1190,14 +1194,11 @@ unsigned int type_memsize(const type_t *t, unsigned int *align)
     case TYPE_ENUM:
         switch (get_enum_fc(t))
         {
+        case RPC_FC_ENUM16:
         case RPC_FC_ENUM32:
             size = 4;
             if (size > *align) *align = size;
             break;
-        case RPC_FC_ENUM16:
-            size = 2;
-            if (size > *align) *align = size;
-            break;
         default:
             error("type_memsize: Unknown enum type\n");
             size = 0;
@@ -1517,12 +1518,15 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
 
     if (fs) LIST_FOR_EACH_ENTRY(f, fs, var_t, entry)
     {
-        unsigned int align = 0;
         type_t *ft = f->type;
+        unsigned int size = field_memsize( ft, &offset );
         if (type_get_type(ft) == TYPE_UNION && is_attr(f->attrs, ATTR_SWITCHIS))
         {
+            short reloff;
             unsigned int absoff = ft->typestring_offset;
-            short reloff = absoff - (*tfsoff + 6);
+            if (is_attr(ft->attrs, ATTR_SWITCHTYPE))
+                absoff += 8; /* we already have a corr descr, skip it */
+            reloff = absoff - (*tfsoff + 6);
             print_file(file, 0, "/* %d */\n", *tfsoff);
             print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION);
             print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", RPC_FC_LONG);
@@ -1532,9 +1536,7 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
                        reloff, reloff, absoff);
             *tfsoff += 8;
         }
-
-        /* FIXME: take alignment into account */
-        offset += type_memsize(ft, &align);
+        offset += size;
     }
 }
 
@@ -2199,19 +2201,19 @@ static void write_struct_members(FILE *file, const type_t *type,
 {
     const var_t *field;
     unsigned short offset = 0;
-    int salign = -1;
+    unsigned int salign = 1;
     int padding;
     var_list_t *fields = type_struct_get_fields(type);
 
     if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
     {
         type_t *ft = field->type;
+        unsigned int align = 0;
+        unsigned int size = type_memsize(ft, &align);
+        if (salign < align) salign = align;
+
         if (!is_conformant_array(ft) || type_array_is_decl_as_ptr(ft))
         {
-            unsigned int align = 0;
-            unsigned int size = type_memsize(ft, &align);
-            if (salign == -1)
-                salign = align;
             if ((align - 1) & offset)
             {
                 unsigned char fc = 0;
@@ -2313,8 +2315,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
         /* On the sizing pass, type->ptrdesc may be zero, but it's ok as
            nothing is written to file yet.  On the actual writing pass,
            this will have been updated.  */
-        unsigned int absoff = type_get_real_type(type)->ptrdesc ?
-            type_get_real_type(type)->ptrdesc : *tfsoff;
+        unsigned int absoff = type->ptrdesc ? type->ptrdesc : *tfsoff;
         int reloff = absoff - *tfsoff;
         assert( reloff >= 0 );
         print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %d (%u) */\n",
@@ -2340,7 +2341,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
     {
         const var_t *f;
 
-        type_get_real_type(type)->ptrdesc = *tfsoff;
+        type->ptrdesc = *tfsoff;
         if (fields) LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry)
         {
             type_t *ft = f->type;
@@ -2365,8 +2366,8 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type,
                 write_nonsimple_pointer(file, f->attrs, ft, FALSE, offset, tfsoff);
             }
         }
-        if (type_get_real_type(type)->ptrdesc == *tfsoff)
-            type_get_real_type(type)->ptrdesc = 0;
+        if (type->ptrdesc == *tfsoff)
+            type->ptrdesc = 0;
     }
 
     current_structure = save_current_structure;
@@ -2509,6 +2510,7 @@ static unsigned int write_union_tfs(FILE *file, type_t *type, unsigned int *tfso
         *tfsoff += write_conf_or_var_desc(file, NULL, *tfsoff, st, &dummy_expr );
         print_file(file, 2, "NdrFcShort(0x2),\t/* Offset= 2 (%u) */\n", *tfsoff + 2);
         *tfsoff += 2;
+        print_file(file, 0, "/* %u */\n", *tfsoff);
     }
 
     print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", size, size);
@@ -3989,6 +3991,19 @@ void write_exceptions( FILE *file )
     fprintf( file, "    __DECL_EXCEPTION_FRAME\n");
     fprintf( file, "};\n");
     fprintf( file, "\n");
+    fprintf( file, "static inline void __widl_unwind_target(void)\n" );
+    fprintf( file, "{\n");
+    fprintf( file, "    struct __exception_frame *exc_frame = (struct __exception_frame *)__wine_get_frame();\n" );
+    fprintf( file, "    if (exc_frame->finally_level > exc_frame->filter_level)\n" );
+    fprintf( file, "    {\n");
+    fprintf( file, "        exc_frame->abnormal_termination = 1;\n");
+    fprintf( file, "        exc_frame->finally( exc_frame );\n");
+    fprintf( file, "        __wine_pop_frame( &exc_frame->frame );\n");
+    fprintf( file, "    }\n");
+    fprintf( file, "    exc_frame->filter_level = 0;\n");
+    fprintf( file, "    siglongjmp( exc_frame->jmp, 1 );\n");
+    fprintf( file, "}\n");
+    fprintf( file, "\n");
     fprintf( file, "static DWORD __widl_exception_handler( EXCEPTION_RECORD *record,\n");
     fprintf( file, "                                       EXCEPTION_REGISTRATION_RECORD *frame,\n");
     fprintf( file, "                                       CONTEXT *context,\n");
@@ -4007,17 +4022,7 @@ void write_exceptions( FILE *file )
     fprintf( file, "    }\n" );
     fprintf( file, "    exc_frame->code = record->ExceptionCode;\n");
     fprintf( file, "    if (exc_frame->filter_level && exc_frame->filter( record, exc_frame ) == EXCEPTION_EXECUTE_HANDLER)\n" );
-    fprintf( file, "    {\n");
-    fprintf( file, "        __wine_rtl_unwind( frame, record );\n");
-    fprintf( file, "        if (exc_frame->finally_level > exc_frame->filter_level)\n" );
-    fprintf( file, "        {\n");
-    fprintf( file, "            exc_frame->abnormal_termination = 1;\n");
-    fprintf( file, "            exc_frame->finally( exc_frame );\n");
-    fprintf( file, "            __wine_pop_frame( frame );\n");
-    fprintf( file, "        }\n");
-    fprintf( file, "        exc_frame->filter_level = 0;\n");
-    fprintf( file, "        siglongjmp( exc_frame->jmp, 1 );\n");
-    fprintf( file, "    }\n");
+    fprintf( file, "        __wine_rtl_unwind( frame, record, __widl_unwind_target );\n");
     fprintf( file, "    return ExceptionContinueSearch;\n");
     fprintf( file, "}\n");
     fprintf( file, "\n");
index 70c5d25..2f1e9f7 100644 (file)
@@ -129,6 +129,7 @@ enum attr_type
     ATTR_OLEAUTOMATION,
     ATTR_OPTIONAL,
     ATTR_OUT,
+    ATTR_PARAMLCID,
     ATTR_POINTERDEFAULT,
     ATTR_POINTERTYPE,
     ATTR_PROPGET,
index a53f454..703b583 100644 (file)
@@ -139,7 +139,7 @@ static void ctl2_init_header(
     typelib->typelib_header.magic1 = 0x5446534d;
     typelib->typelib_header.magic2 = 0x00010002;
     typelib->typelib_header.posguid = -1;
-    typelib->typelib_header.lcid = 0x0409; /* or do we use the current one? */
+    typelib->typelib_header.lcid = 0x0409;
     typelib->typelib_header.lcid2 = 0x0;
     typelib->typelib_header.varflags = 0x40;
     typelib->typelib_header.version = 0;
@@ -1265,6 +1265,7 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
     unsigned int funckind, invokekind = 1 /* INVOKE_FUNC */;
     int help_context = 0, help_string_context = 0, help_string_offset = -1;
     int entry = -1, entry_is_ord = 0;
+    int lcid_retval_count = 0;
 
     chat("add_func_desc(%p,%d)\n", typeinfo, index);
 
@@ -1495,9 +1496,13 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
             case ATTR_OUT:
                 paramflags |= 0x02; /* PARAMFLAG_FOUT */
                 break;
+            case ATTR_PARAMLCID:
+                paramflags |= 0x04; /* PARAMFLAG_LCID */
+                lcid_retval_count++;
+                break;
             case ATTR_RETVAL:
                 paramflags |= 0x08; /* PARAMFLAG_FRETVAL */
-                typedata[4] |= 0x4000;
+                lcid_retval_count++;
                 break;
             default:
                 chat("unhandled param attr %d\n", attr->type);
@@ -1507,10 +1512,16 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index)
        paramdata[1] = -1;
        paramdata[2] = paramflags;
        typedata[3] += decoded_size << 16;
+
         i++;
       }
     }
 
+    if(lcid_retval_count == 1)
+        typedata[4] |= 0x4000;
+    else if(lcid_retval_count == 2)
+        typedata[4] |= 0x8000;
+
     if(typeinfo->funcs_allocated == 0) {
         typeinfo->funcs_allocated = 10;
         typeinfo->func_indices = xmalloc(typeinfo->funcs_allocated * sizeof(int));
@@ -2349,7 +2360,11 @@ static void set_help_string_context(msft_typelib_t *typelib)
 static void set_lcid(msft_typelib_t *typelib)
 {
     const expr_t *lcid_expr = get_attrp( typelib->typelib->attrs, ATTR_LIBLCID );
-    typelib->typelib_header.lcid2 = lcid_expr ? lcid_expr->cval : 0x0;
+    if(lcid_expr)
+    {
+        typelib->typelib_header.lcid  = lcid_expr->cval;
+        typelib->typelib_header.lcid2 = lcid_expr->cval;
+    }
 }
 
 static void set_lib_flags(msft_typelib_t *typelib)