diff --git a/reactos/tools/widl/client.c b/reactos/tools/widl/client.c index be42b1b8122..739dba9c913 100644 --- a/reactos/tools/widl/client.c +++ b/reactos/tools/widl/client.c @@ -74,9 +74,9 @@ static void write_function_stub( const type_t *iface, const var_t *func, { unsigned char explicit_fc, implicit_fc; int has_full_pointer = is_full_pointer_function(func); - type_t *rettype = type_function_get_rettype(func->type); + var_t *retval = type_function_get_retval(func->type); const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); - int has_ret = !is_void(rettype); + int has_ret = !is_void(retval->type); if (is_interpreted_func( iface, func )) { @@ -97,9 +97,9 @@ static void write_function_stub( const type_t *iface, const var_t *func, print_client("RPC_BINDING_HANDLE _Handle;\n"); } - if (has_ret && decl_indirect(rettype)) + if (has_ret && decl_indirect(retval->type)) { - print_client("void *_p_%s;\n", "_RetVal" ); + print_client("void *_p_%s;\n", retval->name); } indent--; print_client( "};\n\n" ); @@ -132,12 +132,12 @@ static void write_function_stub( const type_t *iface, const var_t *func, indent++; print_client( "struct __frame_%s%s __f, * const __frame = &__f;\n", prefix_client, get_name(func) ); - /* declare return value '_RetVal' */ + /* declare return value */ if (has_ret) { print_client("%s", ""); - write_type_decl_left(client, rettype); - fprintf(client, " _RetVal;\n"); + write_type_decl(client, retval->type, retval->name); + fprintf(client, ";\n"); } print_client("RPC_MESSAGE _RpcMessage;\n"); @@ -147,10 +147,9 @@ static void write_function_stub( const type_t *iface, const var_t *func, if (explicit_fc == RPC_FC_BIND_GENERIC) print_client("__frame->%s = %s;\n", handle_var->name, handle_var->name ); } - if (has_ret && decl_indirect(rettype)) + if (has_ret && decl_indirect(retval->type)) { - print_client("__frame->_p_%s = &%s;\n", - "_RetVal", "_RetVal"); + print_client("__frame->_p_%s = &%s;\n", retval->name, retval->name); } fprintf(client, "\n"); @@ -258,10 +257,10 @@ static void write_function_stub( const type_t *iface, const var_t *func, /* unmarshal return value */ if (has_ret) { - if (decl_indirect(rettype)) - print_client("MIDL_memset(&%s, 0, sizeof(%s));\n", "_RetVal", "_RetVal"); - else if (is_ptr(rettype) || is_array(rettype)) - print_client("%s = 0;\n", "_RetVal"); + if (decl_indirect(retval->type)) + print_client("MIDL_memset(&%s, 0, sizeof(%s));\n", retval->name, retval->name); + else if (is_ptr(retval->type) || is_array(retval->type)) + print_client("%s = 0;\n", retval->name); write_remoting_arguments(client, indent, func, "", PASS_RETURN, PHASE_UNMARSHAL); } @@ -280,7 +279,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, if (has_ret) { fprintf(client, "\n"); - print_client("return _RetVal;\n"); + print_client("return %s;\n", retval->name); } indent--; @@ -472,8 +471,6 @@ static void write_client_ifaces(const statement_list_t *stmts, int expr_eval_rou write_stubdescriptor(iface, expr_eval_routines); } } - else if (stmt->type == STMT_LIBRARY) - write_client_ifaces(stmt->u.lib->stmts, expr_eval_routines, proc_offset); } } diff --git a/reactos/tools/widl/header.c b/reactos/tools/widl/header.c index 9d20a3ee2bd..00d6e76caf0 100644 --- a/reactos/tools/widl/header.c +++ b/reactos/tools/widl/header.c @@ -987,8 +987,6 @@ static void write_local_stubs_stmts(FILE *local_stubs, const statement_list_t *s { if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) write_locals(local_stubs, stmt->u.type, TRUE); - else if (stmt->type == STMT_LIBRARY) - write_local_stubs_stmts(local_stubs, stmt->u.lib->stmts); } } @@ -1360,10 +1358,15 @@ void write_header(const statement_list_t *stmts) return; } fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION, input_name); + + fprintf(header, "#ifndef __REQUIRED_RPCNDR_H_VERSION__\n"); + fprintf(header, "#define __REQUIRED_RPCNDR_H_VERSION__ 475\n"); + fprintf(header, "#endif\n\n"); + fprintf(header, "#include \n" ); fprintf(header, "#include \n\n" ); - fprintf(header, "#if !defined(COM_NO_WINDOWS_H) && !defined(__WINESRC__)\n"); + fprintf(header, "#ifndef COM_NO_WINDOWS_H\n"); fprintf(header, "#include \n"); fprintf(header, "#include \n"); fprintf(header, "#endif\n\n"); diff --git a/reactos/tools/widl/parser.tab.c b/reactos/tools/widl/parser.tab.c index 1bc7eb5ffd3..8af5e8d13bf 100644 --- a/reactos/tools/widl/parser.tab.c +++ b/reactos/tools/widl/parser.tab.c @@ -1,9 +1,8 @@ -/* A Bison parser, made by GNU Bison 2.4.2. */ +/* A Bison parser, made by GNU Bison 2.5. */ -/* Skeleton implementation for Bison's Yacc-like parsers in C +/* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software - Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -45,7 +44,7 @@ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "2.4.2" +#define YYBISON_VERSION "2.5" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -74,7 +73,7 @@ /* Copy the first part of user declarations. */ -/* Line 189 of yacc.c */ +/* Line 268 of yacc.c */ #line 1 "parser.y" /* @@ -229,8 +228,8 @@ static statement_list_t *append_statement(statement_list_t *list, statement_t *s -/* Line 189 of yacc.c */ -#line 234 "parser.tab.c" +/* Line 268 of yacc.c */ +#line 233 "parser.tab.c" /* Enabling traces. */ #ifndef YYDEBUG @@ -447,7 +446,7 @@ static statement_list_t *append_statement(statement_list_t *list, statement_t *s typedef union YYSTYPE { -/* Line 214 of yacc.c */ +/* Line 293 of yacc.c */ #line 153 "parser.y" attr_t *attr; @@ -477,8 +476,8 @@ typedef union YYSTYPE -/* Line 214 of yacc.c */ -#line 482 "parser.tab.c" +/* Line 293 of yacc.c */ +#line 481 "parser.tab.c" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ @@ -489,8 +488,8 @@ typedef union YYSTYPE /* Copy the second part of user declarations. */ -/* Line 264 of yacc.c */ -#line 494 "parser.tab.c" +/* Line 343 of yacc.c */ +#line 493 "parser.tab.c" #ifdef short # undef short @@ -593,11 +592,11 @@ YYID (yyi) # define alloca _alloca # else # define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 # endif # endif # endif @@ -620,24 +619,24 @@ YYID (yyi) # ifndef YYSTACK_ALLOC_MAXIMUM # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM # endif -# if (defined __cplusplus && ! defined _STDLIB_H \ +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ && ! ((defined YYMALLOC || defined malloc) \ && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 # endif # endif # ifndef YYMALLOC # define YYMALLOC malloc -# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free -# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif @@ -666,23 +665,7 @@ union yyalloc ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAXIMUM) -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (YYID (0)) -# endif -# endif +# define YYCOPY_NEEDED 1 /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of @@ -702,6 +685,26 @@ union yyalloc #endif +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ @@ -1166,8 +1169,8 @@ static const yytype_uint8 yyr2[] = 3 }; -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ static const yytype_uint16 yydefact[] = { @@ -1346,8 +1349,7 @@ static const yytype_int16 yypgoto[] = /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 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. */ + number is the opposite. If YYTABLE_NINF, syntax error. */ #define YYTABLE_NINF -248 static const yytype_int16 yytable[] = { @@ -1628,6 +1630,12 @@ static const yytype_int16 yytable[] = 0, 0, 194 }; +#define yypact_value_is_default(yystate) \ + ((yystate) == (-509)) + +#define yytable_value_is_error(yytable_value) \ + YYID (0) + static const yytype_int16 yycheck[] = { 2, 66, 2, 2, 2, 301, 33, 271, 2, 318, @@ -2013,7 +2021,6 @@ do \ { \ yychar = (Token); \ yylval = (Value); \ - yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK (1); \ goto yybackup; \ } \ @@ -2055,19 +2062,10 @@ while (YYID (0)) #endif -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ +/* This macro is provided for backward compatibility. */ #ifndef YY_LOCATION_PRINT -# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) #endif @@ -2259,7 +2257,6 @@ int yydebug; # define YYMAXDEPTH 10000 #endif - #if YYERROR_VERBOSE @@ -2362,115 +2359,142 @@ yytnamerr (char *yyres, const char *yystr) } # endif -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -yysyntax_error (char *yyresult, int yystate, int yychar) +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) { - int yyn = yypact[yystate]; + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; - if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; - else + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr (0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - - if (yysize_overflow) - return YYSIZE_MAXIMUM; - - if (yyresult) - { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char *yyp = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - } - return yysize; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; } #endif /* YYERROR_VERBOSE */ - /*-----------------------------------------------. | Release the memory associated to this symbol. | @@ -2503,6 +2527,7 @@ yydestruct (yymsg, yytype, yyvaluep) } } + /* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM #if defined __STDC__ || defined __cplusplus @@ -2529,10 +2554,9 @@ YYSTYPE yylval; int yynerrs; - -/*-------------------------. -| yyparse or yypush_parse. | -`-------------------------*/ +/*----------. +| yyparse. | +`----------*/ #ifdef YYPARSE_PARAM #if (defined __STDC__ || defined __C99__FUNC__ \ @@ -2556,8 +2580,6 @@ yyparse () #endif #endif { - - int yystate; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; @@ -2712,7 +2734,7 @@ yybackup: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) + if (yypact_value_is_default (yyn)) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ @@ -2743,8 +2765,8 @@ yybackup: yyn = yytable[yyn]; if (yyn <= 0) { - if (yyn == 0 || yyn == YYTABLE_NINF) - goto yyerrlab; + if (yytable_value_is_error (yyn)) + goto yyerrlab; yyn = -yyn; goto yyreduce; } @@ -2799,7 +2821,7 @@ yyreduce: { case 2: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 328 "parser.y" { fix_incomplete(); check_statements((yyvsp[(1) - (1)].stmt_list), FALSE); @@ -2812,1203 +2834,1203 @@ yyreduce: write_regscript((yyvsp[(1) - (1)].stmt_list)); write_dlldata((yyvsp[(1) - (1)].stmt_list)); write_local_stubs((yyvsp[(1) - (1)].stmt_list)); - ;} + } break; case 3: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 342 "parser.y" - { (yyval.stmt_list) = NULL; ;} + { (yyval.stmt_list) = NULL; } break; case 4: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 343 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_reference((yyvsp[(2) - (2)].type))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_reference((yyvsp[(2) - (2)].type))); } break; case 5: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 344 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); } break; case 6: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 345 "parser.y" { (yyval.stmt_list) = (yyvsp[(1) - (3)].stmt_list); reg_type((yyvsp[(2) - (3)].type), (yyvsp[(2) - (3)].type)->name, 0); - ;} + } break; case 7: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 348 "parser.y" { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); reg_type((yyvsp[(2) - (2)].type), (yyvsp[(2) - (2)].type)->name, 0); - ;} + } break; case 8: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 351 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_module((yyvsp[(2) - (2)].type))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_module((yyvsp[(2) - (2)].type))); } break; case 9: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 352 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_library((yyvsp[(2) - (2)].typelib))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_library((yyvsp[(2) - (2)].typelib))); } break; case 10: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 353 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); } break; case 11: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 356 "parser.y" - { (yyval.stmt_list) = NULL; ;} + { (yyval.stmt_list) = NULL; } break; case 12: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 357 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_reference((yyvsp[(2) - (2)].type))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_reference((yyvsp[(2) - (2)].type))); } break; case 13: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 358 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); } break; case 14: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 359 "parser.y" - { (yyval.stmt_list) = (yyvsp[(1) - (3)].stmt_list); reg_type((yyvsp[(2) - (3)].type), (yyvsp[(2) - (3)].type)->name, 0); ;} + { (yyval.stmt_list) = (yyvsp[(1) - (3)].stmt_list); reg_type((yyvsp[(2) - (3)].type), (yyvsp[(2) - (3)].type)->name, 0); } break; case 15: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 360 "parser.y" { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_type_decl((yyvsp[(2) - (2)].type))); reg_type((yyvsp[(2) - (2)].type), (yyvsp[(2) - (2)].type)->name, 0); - ;} + } break; case 16: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 363 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_module((yyvsp[(2) - (2)].type))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_module((yyvsp[(2) - (2)].type))); } break; case 17: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 364 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); } break; case 18: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 365 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_importlib((yyvsp[(2) - (2)].str))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_importlib((yyvsp[(2) - (2)].str))); } break; case 19: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 366 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_library((yyvsp[(2) - (2)].typelib))); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), make_statement_library((yyvsp[(2) - (2)].typelib))); } break; case 20: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 369 "parser.y" - { (yyval.stmt_list) = NULL; ;} + { (yyval.stmt_list) = NULL; } break; case 21: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 370 "parser.y" - { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); ;} + { (yyval.stmt_list) = append_statement((yyvsp[(1) - (2)].stmt_list), (yyvsp[(2) - (2)].statement)); } break; case 24: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 378 "parser.y" - { (yyval.statement) = make_statement_cppquote((yyvsp[(1) - (1)].str)); ;} + { (yyval.statement) = make_statement_cppquote((yyvsp[(1) - (1)].str)); } break; case 25: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 379 "parser.y" - { (yyval.statement) = make_statement_type_decl((yyvsp[(1) - (2)].type)); ;} + { (yyval.statement) = make_statement_type_decl((yyvsp[(1) - (2)].type)); } break; case 26: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 380 "parser.y" - { (yyval.statement) = make_statement_declaration((yyvsp[(1) - (2)].var)); ;} + { (yyval.statement) = make_statement_declaration((yyvsp[(1) - (2)].var)); } break; case 27: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 381 "parser.y" - { (yyval.statement) = make_statement_import((yyvsp[(1) - (1)].str)); ;} + { (yyval.statement) = make_statement_import((yyvsp[(1) - (1)].str)); } break; case 28: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 382 "parser.y" - { (yyval.statement) = (yyvsp[(1) - (2)].statement); ;} + { (yyval.statement) = (yyvsp[(1) - (2)].statement); } break; case 30: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 387 "parser.y" - { (yyval.type) = type_new_enum((yyvsp[(2) - (2)].str), FALSE, NULL); ;} + { (yyval.type) = type_new_enum((yyvsp[(2) - (2)].str), FALSE, NULL); } break; case 32: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 389 "parser.y" - { (yyval.type) = type_new_struct((yyvsp[(2) - (2)].str), FALSE, NULL); ;} + { (yyval.type) = type_new_struct((yyvsp[(2) - (2)].str), FALSE, NULL); } break; case 34: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 391 "parser.y" - { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (2)].str), FALSE, NULL); ;} + { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (2)].str), FALSE, NULL); } break; case 35: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 392 "parser.y" - { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[(1) - (2)].attr_list)); ;} + { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[(1) - (2)].attr_list)); } break; case 36: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 393 "parser.y" - { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[(1) - (2)].attr_list)); ;} + { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[(1) - (2)].attr_list)); } break; case 37: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 394 "parser.y" - { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_union_attrs((yyvsp[(1) - (2)].attr_list)); ;} + { (yyval.type) = (yyvsp[(2) - (2)].type); (yyval.type)->attrs = check_union_attrs((yyvsp[(1) - (2)].attr_list)); } break; case 38: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 397 "parser.y" - { (yyval.str) = (yyvsp[(3) - (4)].str); ;} + { (yyval.str) = (yyvsp[(3) - (4)].str); } break; case 39: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 399 "parser.y" { assert(yychar == YYEMPTY); (yyval.import) = xmalloc(sizeof(struct _import_t)); (yyval.import)->name = (yyvsp[(2) - (3)].str); (yyval.import)->import_performed = do_import((yyvsp[(2) - (3)].str)); if (!(yyval.import)->import_performed) yychar = aEOF; - ;} + } break; case 40: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 407 "parser.y" { (yyval.str) = (yyvsp[(1) - (3)].import)->name; if ((yyvsp[(1) - (3)].import)->import_performed) pop_import(); free((yyvsp[(1) - (3)].import)); - ;} + } break; case 41: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 414 "parser.y" - { (yyval.str) = (yyvsp[(3) - (5)].str); if(!parse_only) add_importlib((yyvsp[(3) - (5)].str)); ;} + { (yyval.str) = (yyvsp[(3) - (5)].str); if(!parse_only) add_importlib((yyvsp[(3) - (5)].str)); } break; case 42: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 417 "parser.y" - { (yyval.str) = (yyvsp[(2) - (2)].str); ;} + { (yyval.str) = (yyvsp[(2) - (2)].str); } break; case 43: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 419 "parser.y" { (yyval.typelib) = make_library((yyvsp[(2) - (3)].str), check_library_attrs((yyvsp[(2) - (3)].str), (yyvsp[(1) - (3)].attr_list))); if (!parse_only) start_typelib((yyval.typelib)); - ;} + } break; case 44: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 424 "parser.y" { (yyval.typelib) = (yyvsp[(1) - (4)].typelib); (yyval.typelib)->stmts = (yyvsp[(2) - (4)].stmt_list); if (!parse_only) end_typelib(); - ;} + } break; case 45: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 430 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 47: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 434 "parser.y" - { check_arg_attrs((yyvsp[(1) - (1)].var)); (yyval.var_list) = append_var( NULL, (yyvsp[(1) - (1)].var) ); ;} + { check_arg_attrs((yyvsp[(1) - (1)].var)); (yyval.var_list) = append_var( NULL, (yyvsp[(1) - (1)].var) ); } break; case 48: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 435 "parser.y" - { check_arg_attrs((yyvsp[(3) - (3)].var)); (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(3) - (3)].var) ); ;} + { check_arg_attrs((yyvsp[(3) - (3)].var)); (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(3) - (3)].var) ); } break; case 50: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 439 "parser.y" - { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), make_var(strdup("...")) ); ;} + { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), make_var(strdup("...")) ); } break; case 51: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 443 "parser.y" { if ((yyvsp[(2) - (3)].declspec)->stgclass != STG_NONE && (yyvsp[(2) - (3)].declspec)->stgclass != STG_REGISTER) error_loc("invalid storage class for function parameter\n"); (yyval.var) = declare_var((yyvsp[(1) - (3)].attr_list), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), TRUE); free((yyvsp[(2) - (3)].declspec)); free((yyvsp[(3) - (3)].declarator)); - ;} + } break; case 52: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 448 "parser.y" { if ((yyvsp[(1) - (2)].declspec)->stgclass != STG_NONE && (yyvsp[(1) - (2)].declspec)->stgclass != STG_REGISTER) error_loc("invalid storage class for function parameter\n"); (yyval.var) = declare_var(NULL, (yyvsp[(1) - (2)].declspec), (yyvsp[(2) - (2)].declarator), TRUE); free((yyvsp[(1) - (2)].declspec)); free((yyvsp[(2) - (2)].declarator)); - ;} + } break; case 53: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 455 "parser.y" { (yyval.expr) = (yyvsp[(2) - (3)].expr); if (!(yyval.expr)->is_const) error_loc("array dimension is not an integer constant\n"); - ;} + } break; case 54: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 459 "parser.y" - { (yyval.expr) = make_expr(EXPR_VOID); ;} + { (yyval.expr) = make_expr(EXPR_VOID); } break; case 55: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 460 "parser.y" - { (yyval.expr) = make_expr(EXPR_VOID); ;} + { (yyval.expr) = make_expr(EXPR_VOID); } break; case 56: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 463 "parser.y" - { (yyval.attr_list) = NULL; ;} + { (yyval.attr_list) = NULL; } break; case 58: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 468 "parser.y" - { (yyval.attr_list) = (yyvsp[(2) - (3)].attr_list); ;} + { (yyval.attr_list) = (yyvsp[(2) - (3)].attr_list); } break; case 59: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 471 "parser.y" - { (yyval.attr_list) = append_attr( NULL, (yyvsp[(1) - (1)].attr) ); ;} + { (yyval.attr_list) = append_attr( NULL, (yyvsp[(1) - (1)].attr) ); } break; case 60: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 472 "parser.y" - { (yyval.attr_list) = append_attr( (yyvsp[(1) - (3)].attr_list), (yyvsp[(3) - (3)].attr) ); ;} + { (yyval.attr_list) = append_attr( (yyvsp[(1) - (3)].attr_list), (yyvsp[(3) - (3)].attr) ); } break; case 61: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 473 "parser.y" - { (yyval.attr_list) = append_attr( (yyvsp[(1) - (4)].attr_list), (yyvsp[(4) - (4)].attr) ); ;} + { (yyval.attr_list) = append_attr( (yyvsp[(1) - (4)].attr_list), (yyvsp[(4) - (4)].attr) ); } break; case 62: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 476 "parser.y" - { (yyval.str_list) = append_str( NULL, (yyvsp[(1) - (1)].str) ); ;} + { (yyval.str_list) = append_str( NULL, (yyvsp[(1) - (1)].str) ); } break; case 63: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 477 "parser.y" - { (yyval.str_list) = append_str( (yyvsp[(1) - (3)].str_list), (yyvsp[(3) - (3)].str) ); ;} + { (yyval.str_list) = append_str( (yyvsp[(1) - (3)].str_list), (yyvsp[(3) - (3)].str) ); } break; case 64: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 480 "parser.y" - { (yyval.attr) = NULL; ;} + { (yyval.attr) = NULL; } break; case 65: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 481 "parser.y" - { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); ;} + { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); } break; case 66: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 482 "parser.y" - { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[(3) - (4)].str)); } break; case 67: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 483 "parser.y" - { (yyval.attr) = make_attr(ATTR_APPOBJECT); ;} + { (yyval.attr) = make_attr(ATTR_APPOBJECT); } break; case 68: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 484 "parser.y" - { (yyval.attr) = make_attr(ATTR_ASYNC); ;} + { (yyval.attr) = make_attr(ATTR_ASYNC); } break; case 69: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 485 "parser.y" - { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); ;} + { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); } break; case 70: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 486 "parser.y" - { (yyval.attr) = make_attr(ATTR_BINDABLE); ;} + { (yyval.attr) = make_attr(ATTR_BINDABLE); } break; case 71: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 487 "parser.y" - { (yyval.attr) = make_attr(ATTR_BROADCAST); ;} + { (yyval.attr) = make_attr(ATTR_BROADCAST); } break; case 72: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 488 "parser.y" - { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[(3) - (4)].var)); ;} + { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[(3) - (4)].var)); } break; case 73: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 489 "parser.y" - { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[(3) - (4)].expr_list)); ;} + { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[(3) - (4)].expr_list)); } break; case 74: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 490 "parser.y" - { (yyval.attr) = make_attr(ATTR_CODE); ;} + { (yyval.attr) = make_attr(ATTR_CODE); } break; case 75: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 491 "parser.y" - { (yyval.attr) = make_attr(ATTR_COMMSTATUS); ;} + { (yyval.attr) = make_attr(ATTR_COMMSTATUS); } break; case 76: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 492 "parser.y" - { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); ;} + { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); } break; case 77: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 493 "parser.y" - { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ ;} + { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ } break; case 78: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 494 "parser.y" - { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ ;} + { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ } break; case 79: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 495 "parser.y" - { (yyval.attr) = make_attr(ATTR_CONTROL); ;} + { (yyval.attr) = make_attr(ATTR_CONTROL); } break; case 80: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 496 "parser.y" - { (yyval.attr) = make_attr(ATTR_DECODE); ;} + { (yyval.attr) = make_attr(ATTR_DECODE); } break; case 81: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 497 "parser.y" - { (yyval.attr) = make_attr(ATTR_DEFAULT); ;} + { (yyval.attr) = make_attr(ATTR_DEFAULT); } break; case 82: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 498 "parser.y" - { (yyval.attr) = make_attr(ATTR_DEFAULTBIND); ;} + { (yyval.attr) = make_attr(ATTR_DEFAULTBIND); } break; case 83: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 499 "parser.y" - { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); ;} + { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); } break; case 84: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 500 "parser.y" - { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[(3) - (4)].expr)); } break; case 85: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 501 "parser.y" - { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); ;} + { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); } break; case 86: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 502 "parser.y" - { (yyval.attr) = make_attr(ATTR_DISABLECONSISTENCYCHECK); ;} + { (yyval.attr) = make_attr(ATTR_DISABLECONSISTENCYCHECK); } break; case 87: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 503 "parser.y" - { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); ;} + { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); } break; case 88: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 504 "parser.y" - { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[(3) - (4)].str)); } break; case 89: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 505 "parser.y" - { (yyval.attr) = make_attr(ATTR_DUAL); ;} + { (yyval.attr) = make_attr(ATTR_DUAL); } break; case 90: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 506 "parser.y" - { (yyval.attr) = make_attr(ATTR_ENABLEALLOCATE); ;} + { (yyval.attr) = make_attr(ATTR_ENABLEALLOCATE); } break; case 91: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 507 "parser.y" - { (yyval.attr) = make_attr(ATTR_ENCODE); ;} + { (yyval.attr) = make_attr(ATTR_ENCODE); } break; case 92: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 508 "parser.y" - { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[(3) - (4)].str_list)); ;} + { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[(3) - (4)].str_list)); } break; case 93: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 509 "parser.y" - { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[(3) - (4)].expr)); } break; case 94: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 510 "parser.y" - { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); ;} + { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); } break; case 95: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 511 "parser.y" - { (yyval.attr) = make_attr(ATTR_FAULTSTATUS); ;} + { (yyval.attr) = make_attr(ATTR_FAULTSTATUS); } break; case 96: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 512 "parser.y" - { (yyval.attr) = make_attr(ATTR_FORCEALLOCATE); ;} + { (yyval.attr) = make_attr(ATTR_FORCEALLOCATE); } break; case 97: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 513 "parser.y" - { (yyval.attr) = make_attr(ATTR_HANDLE); ;} + { (yyval.attr) = make_attr(ATTR_HANDLE); } break; case 98: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 514 "parser.y" - { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[(3) - (4)].expr)); } break; case 99: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 515 "parser.y" - { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[(3) - (4)].str)); } break; case 100: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 516 "parser.y" - { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[(3) - (4)].str)); } break; case 101: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 517 "parser.y" - { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[(3) - (4)].expr)); } break; case 102: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 518 "parser.y" - { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[(3) - (4)].str)); } break; case 103: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 519 "parser.y" - { (yyval.attr) = make_attr(ATTR_HIDDEN); ;} + { (yyval.attr) = make_attr(ATTR_HIDDEN); } break; case 104: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 520 "parser.y" - { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[(3) - (4)].expr)); } break; case 105: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 521 "parser.y" - { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); ;} + { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); } break; case 106: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 522 "parser.y" - { (yyval.attr) = make_attr(ATTR_IGNORE); ;} + { (yyval.attr) = make_attr(ATTR_IGNORE); } break; case 107: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 523 "parser.y" - { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[(3) - (4)].expr)); } break; case 108: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 524 "parser.y" - { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); ;} + { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); } break; case 109: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 525 "parser.y" - { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[(3) - (4)].var)); ;} + { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[(3) - (4)].var)); } break; case 110: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 526 "parser.y" - { (yyval.attr) = make_attr(ATTR_IN); ;} + { (yyval.attr) = make_attr(ATTR_IN); } break; case 111: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 527 "parser.y" - { (yyval.attr) = make_attr(ATTR_INPUTSYNC); ;} + { (yyval.attr) = make_attr(ATTR_INPUTSYNC); } break; case 112: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 528 "parser.y" - { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[(3) - (4)].expr_list)); ;} + { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[(3) - (4)].expr_list)); } break; case 113: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 529 "parser.y" - { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[(3) - (4)].expr)); } break; case 114: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 530 "parser.y" - { (yyval.attr) = make_attr(ATTR_PARAMLCID); ;} + { (yyval.attr) = make_attr(ATTR_PARAMLCID); } break; case 115: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 531 "parser.y" - { (yyval.attr) = make_attr(ATTR_LICENSED); ;} + { (yyval.attr) = make_attr(ATTR_LICENSED); } break; case 116: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 532 "parser.y" - { (yyval.attr) = make_attr(ATTR_LOCAL); ;} + { (yyval.attr) = make_attr(ATTR_LOCAL); } break; case 117: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 533 "parser.y" - { (yyval.attr) = make_attr(ATTR_MAYBE); ;} + { (yyval.attr) = make_attr(ATTR_MAYBE); } break; case 118: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 534 "parser.y" - { (yyval.attr) = make_attr(ATTR_MESSAGE); ;} + { (yyval.attr) = make_attr(ATTR_MESSAGE); } break; case 119: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 535 "parser.y" - { (yyval.attr) = make_attr(ATTR_NOCODE); ;} + { (yyval.attr) = make_attr(ATTR_NOCODE); } break; case 120: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 536 "parser.y" - { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;} + { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); } break; case 121: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 537 "parser.y" - { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;} + { (yyval.attr) = make_attr(ATTR_NONCREATABLE); } break; case 122: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 538 "parser.y" - { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;} + { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); } break; case 123: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 539 "parser.y" - { (yyval.attr) = make_attr(ATTR_NOTIFY); ;} + { (yyval.attr) = make_attr(ATTR_NOTIFY); } break; case 124: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 540 "parser.y" - { (yyval.attr) = make_attr(ATTR_NOTIFYFLAG); ;} + { (yyval.attr) = make_attr(ATTR_NOTIFYFLAG); } break; case 125: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 541 "parser.y" - { (yyval.attr) = make_attr(ATTR_OBJECT); ;} + { (yyval.attr) = make_attr(ATTR_OBJECT); } break; case 126: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 542 "parser.y" - { (yyval.attr) = make_attr(ATTR_ODL); ;} + { (yyval.attr) = make_attr(ATTR_ODL); } break; case 127: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 543 "parser.y" - { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;} + { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); } break; case 128: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 544 "parser.y" - { (yyval.attr) = make_attrp(ATTR_OPTIMIZE, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_OPTIMIZE, (yyvsp[(3) - (4)].str)); } break; case 129: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 545 "parser.y" - { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;} + { (yyval.attr) = make_attr(ATTR_OPTIONAL); } break; case 130: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 546 "parser.y" - { (yyval.attr) = make_attr(ATTR_OUT); ;} + { (yyval.attr) = make_attr(ATTR_OUT); } break; case 131: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 547 "parser.y" - { (yyval.attr) = make_attr(ATTR_PARTIALIGNORE); ;} + { (yyval.attr) = make_attr(ATTR_PARTIALIGNORE); } break; case 132: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 548 "parser.y" - { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[(3) - (4)].num)); ;} + { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[(3) - (4)].num)); } break; case 133: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 549 "parser.y" - { (yyval.attr) = make_attrp(ATTR_PROGID, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_PROGID, (yyvsp[(3) - (4)].str)); } break; case 134: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 550 "parser.y" - { (yyval.attr) = make_attr(ATTR_PROPGET); ;} + { (yyval.attr) = make_attr(ATTR_PROPGET); } break; case 135: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 551 "parser.y" - { (yyval.attr) = make_attr(ATTR_PROPPUT); ;} + { (yyval.attr) = make_attr(ATTR_PROPPUT); } break; case 136: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 552 "parser.y" - { (yyval.attr) = make_attr(ATTR_PROPPUTREF); ;} + { (yyval.attr) = make_attr(ATTR_PROPPUTREF); } break; case 137: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 553 "parser.y" - { (yyval.attr) = make_attr(ATTR_PROXY); ;} + { (yyval.attr) = make_attr(ATTR_PROXY); } break; case 138: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 554 "parser.y" - { (yyval.attr) = make_attr(ATTR_PUBLIC); ;} + { (yyval.attr) = make_attr(ATTR_PUBLIC); } break; case 139: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 556 "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); ;} + (yyval.attr) = make_attrp(ATTR_RANGE, list); } break; case 140: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 559 "parser.y" - { (yyval.attr) = make_attr(ATTR_READONLY); ;} + { (yyval.attr) = make_attr(ATTR_READONLY); } break; case 141: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 560 "parser.y" - { (yyval.attr) = make_attrp(ATTR_REPRESENTAS, (yyvsp[(3) - (4)].type)); ;} + { (yyval.attr) = make_attrp(ATTR_REPRESENTAS, (yyvsp[(3) - (4)].type)); } break; case 142: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 561 "parser.y" - { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); ;} + { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); } break; case 143: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 562 "parser.y" - { (yyval.attr) = make_attr(ATTR_RESTRICTED); ;} + { (yyval.attr) = make_attr(ATTR_RESTRICTED); } break; case 144: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 563 "parser.y" - { (yyval.attr) = make_attr(ATTR_RETVAL); ;} + { (yyval.attr) = make_attr(ATTR_RETVAL); } break; case 145: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 564 "parser.y" - { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[(3) - (4)].expr_list)); ;} + { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[(3) - (4)].expr_list)); } break; case 146: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 565 "parser.y" - { (yyval.attr) = make_attr(ATTR_SOURCE); ;} + { (yyval.attr) = make_attr(ATTR_SOURCE); } break; case 147: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 566 "parser.y" - { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); ;} + { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); } break; case 148: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 567 "parser.y" - { (yyval.attr) = make_attr(ATTR_STRING); ;} + { (yyval.attr) = make_attr(ATTR_STRING); } break; case 149: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 568 "parser.y" - { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[(3) - (4)].expr)); ;} + { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[(3) - (4)].expr)); } break; case 150: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 569 "parser.y" - { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[(3) - (4)].type)); ;} + { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[(3) - (4)].type)); } break; case 151: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 570 "parser.y" - { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[(3) - (4)].type)); ;} + { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[(3) - (4)].type)); } break; case 152: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 571 "parser.y" - { (yyval.attr) = make_attrv(ATTR_THREADING, (yyvsp[(3) - (4)].num)); ;} + { (yyval.attr) = make_attrv(ATTR_THREADING, (yyvsp[(3) - (4)].num)); } break; case 153: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 572 "parser.y" - { (yyval.attr) = make_attr(ATTR_UIDEFAULT); ;} + { (yyval.attr) = make_attr(ATTR_UIDEFAULT); } break; case 154: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 573 "parser.y" - { (yyval.attr) = make_attr(ATTR_USESGETLASTERROR); ;} + { (yyval.attr) = make_attr(ATTR_USESGETLASTERROR); } break; case 155: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 574 "parser.y" - { (yyval.attr) = make_attrp(ATTR_USERMARSHAL, (yyvsp[(3) - (4)].type)); ;} + { (yyval.attr) = make_attrp(ATTR_USERMARSHAL, (yyvsp[(3) - (4)].type)); } break; case 156: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 575 "parser.y" - { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[(3) - (4)].uuid)); ;} + { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[(3) - (4)].uuid)); } break; case 157: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 576 "parser.y" - { (yyval.attr) = make_attr(ATTR_V1ENUM); ;} + { (yyval.attr) = make_attr(ATTR_V1ENUM); } break; case 158: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 577 "parser.y" - { (yyval.attr) = make_attr(ATTR_VARARG); ;} + { (yyval.attr) = make_attr(ATTR_VARARG); } break; case 159: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 578 "parser.y" - { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[(3) - (4)].num)); ;} + { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[(3) - (4)].num)); } break; case 160: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 579 "parser.y" - { (yyval.attr) = make_attrp(ATTR_VIPROGID, (yyvsp[(3) - (4)].str)); ;} + { (yyval.attr) = make_attrp(ATTR_VIPROGID, (yyvsp[(3) - (4)].str)); } break; case 161: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 580 "parser.y" - { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[(3) - (4)].type)); ;} + { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[(3) - (4)].type)); } break; case 162: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 581 "parser.y" - { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[(1) - (1)].num)); ;} + { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[(1) - (1)].num)); } break; case 164: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 586 "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)); ;} + (yyval.uuid) = parse_uuid((yyvsp[(1) - (1)].str)); } break; case 165: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 591 "parser.y" - { (yyval.str) = xstrdup("__cdecl"); ;} + { (yyval.str) = xstrdup("__cdecl"); } break; case 166: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 592 "parser.y" - { (yyval.str) = xstrdup("__fastcall"); ;} + { (yyval.str) = xstrdup("__fastcall"); } break; case 167: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 593 "parser.y" - { (yyval.str) = xstrdup("__pascal"); ;} + { (yyval.str) = xstrdup("__pascal"); } break; case 168: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 594 "parser.y" - { (yyval.str) = xstrdup("__stdcall"); ;} + { (yyval.str) = xstrdup("__stdcall"); } break; case 169: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 597 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 170: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 598 "parser.y" - { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;} + { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); } break; case 171: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 601 "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 172: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 605 "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 173: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 611 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 174: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 612 "parser.y" - { (yyval.var_list) = (yyvsp[(1) - (2)].var_list); ;} + { (yyval.var_list) = (yyvsp[(1) - (2)].var_list); } break; case 176: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 616 "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 177: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 620 "parser.y" { if (!(yyvsp[(3) - (3)].var)->eval) { @@ -4016,734 +4038,734 @@ yyreduce: (yyvsp[(3) - (3)].var)->eval = make_exprl(EXPR_NUM, last->eval->cval + 1); } (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(3) - (3)].var) ); - ;} + } break; case 178: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 629 "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 179: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 633 "parser.y" { (yyval.var) = reg_const((yyvsp[(1) - (1)].var)); (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0); - ;} + } break; case 180: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 638 "parser.y" - { (yyval.type) = type_new_enum((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;} + { (yyval.type) = type_new_enum((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); } break; case 181: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 641 "parser.y" - { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;} + { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); } break; case 182: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 642 "parser.y" - { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;} + { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); } break; case 183: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 645 "parser.y" - { (yyval.expr) = make_expr(EXPR_VOID); ;} + { (yyval.expr) = make_expr(EXPR_VOID); } break; case 185: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 649 "parser.y" - { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[(1) - (1)].num)); ;} + { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[(1) - (1)].num)); } break; case 186: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 650 "parser.y" - { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[(1) - (1)].num)); ;} + { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[(1) - (1)].num)); } break; case 187: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 651 "parser.y" - { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[(1) - (1)].dbl)); ;} + { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[(1) - (1)].dbl)); } break; case 188: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 652 "parser.y" - { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); ;} + { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); } break; case 189: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 653 "parser.y" - { (yyval.expr) = make_exprl(EXPR_NUM, 0); ;} + { (yyval.expr) = make_exprl(EXPR_NUM, 0); } break; case 190: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 654 "parser.y" - { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); ;} + { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); } break; case 191: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 655 "parser.y" - { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[(1) - (1)].str)); ;} + { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[(1) - (1)].str)); } break; case 192: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 656 "parser.y" - { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[(1) - (1)].str)); ;} + { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[(1) - (1)].str)); } break; case 193: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 657 "parser.y" - { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[(1) - (1)].str)); ;} + { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[(1) - (1)].str)); } break; case 194: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 658 "parser.y" - { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[(1) - (1)].str)); ;} + { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[(1) - (1)].str)); } break; case 195: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 659 "parser.y" - { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); ;} + { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); } break; case 196: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 660 "parser.y" - { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 197: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 661 "parser.y" - { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 198: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 662 "parser.y" - { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 199: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 663 "parser.y" - { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 200: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 664 "parser.y" - { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 201: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 665 "parser.y" - { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 202: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 666 "parser.y" - { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 203: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 667 "parser.y" - { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 204: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 668 "parser.y" - { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 205: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 669 "parser.y" - { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 206: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 670 "parser.y" - { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 207: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 671 "parser.y" - { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 208: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 672 "parser.y" - { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 209: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 673 "parser.y" - { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 210: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 674 "parser.y" - { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 211: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 675 "parser.y" - { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 212: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 676 "parser.y" - { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 213: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 677 "parser.y" - { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); } break; case 214: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 678 "parser.y" - { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[(2) - (2)].expr)); } break; case 215: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 679 "parser.y" - { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[(2) - (2)].expr)); } break; case 216: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 680 "parser.y" - { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[(2) - (2)].expr)); } break; case 217: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 681 "parser.y" - { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[(2) - (2)].expr)); } break; case 218: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 682 "parser.y" - { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[(2) - (2)].expr)); } break; case 219: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 683 "parser.y" - { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[(2) - (2)].expr)); } break; case 220: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 684 "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_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[(1) - (3)].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); } break; case 221: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 685 "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, (yyvsp[(1) - (3)].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[(3) - (3)].str))); } break; case 222: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 687 "parser.y" - { (yyval.expr) = make_exprt(EXPR_CAST, declare_var(NULL, (yyvsp[(2) - (5)].declspec), (yyvsp[(3) - (5)].declarator), 0), (yyvsp[(5) - (5)].expr)); free((yyvsp[(2) - (5)].declspec)); free((yyvsp[(3) - (5)].declarator)); ;} + { (yyval.expr) = make_exprt(EXPR_CAST, declare_var(NULL, (yyvsp[(2) - (5)].declspec), (yyvsp[(3) - (5)].declarator), 0), (yyvsp[(5) - (5)].expr)); free((yyvsp[(2) - (5)].declspec)); free((yyvsp[(3) - (5)].declarator)); } break; case 223: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 689 "parser.y" - { (yyval.expr) = make_exprt(EXPR_SIZEOF, declare_var(NULL, (yyvsp[(3) - (5)].declspec), (yyvsp[(4) - (5)].declarator), 0), NULL); free((yyvsp[(3) - (5)].declspec)); free((yyvsp[(4) - (5)].declarator)); ;} + { (yyval.expr) = make_exprt(EXPR_SIZEOF, declare_var(NULL, (yyvsp[(3) - (5)].declspec), (yyvsp[(4) - (5)].declarator), 0), NULL); free((yyvsp[(3) - (5)].declspec)); free((yyvsp[(4) - (5)].declarator)); } break; case 224: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 690 "parser.y" - { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); ;} + { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); } break; case 225: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 691 "parser.y" - { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;} + { (yyval.expr) = (yyvsp[(2) - (3)].expr); } break; case 226: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 694 "parser.y" - { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); ;} + { (yyval.expr_list) = append_expr( NULL, (yyvsp[(1) - (1)].expr) ); } break; case 227: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 695 "parser.y" - { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); ;} + { (yyval.expr_list) = append_expr( (yyvsp[(1) - (3)].expr_list), (yyvsp[(3) - (3)].expr) ); } break; case 228: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 698 "parser.y" { (yyval.expr) = (yyvsp[(1) - (1)].expr); if (!(yyval.expr)->is_const) error_loc("expression is not an integer constant\n"); - ;} + } break; case 229: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 704 "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 230: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 710 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 231: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 711 "parser.y" - { (yyval.var_list) = append_var_list((yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var_list)); ;} + { (yyval.var_list) = append_var_list((yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var_list)); } break; case 232: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 715 "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 233: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 719 "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 234: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 726 "parser.y" - { (yyval.var) = (yyvsp[(1) - (2)].var); ;} + { (yyval.var) = (yyvsp[(1) - (2)].var); } break; case 235: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 727 "parser.y" - { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[(1) - (2)].attr_list); ;} + { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[(1) - (2)].attr_list); } break; case 236: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 730 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 237: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 731 "parser.y" - { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); ;} + { (yyval.var_list) = append_var( (yyvsp[(1) - (2)].var_list), (yyvsp[(2) - (2)].var) ); } break; case 238: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 735 "parser.y" - { (yyval.var) = (yyvsp[(1) - (2)].var); ;} + { (yyval.var) = (yyvsp[(1) - (2)].var); } break; case 239: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 736 "parser.y" - { (yyval.var) = NULL; ;} + { (yyval.var) = NULL; } break; case 240: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 739 "parser.y" { (yyval.var) = declare_var(check_field_attrs((yyvsp[(3) - (3)].declarator)->var->name, (yyvsp[(1) - (3)].attr_list)), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE); free((yyvsp[(3) - (3)].declarator)); - ;} + } break; case 241: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 745 "parser.y" { (yyval.var) = (yyvsp[(1) - (1)].var); if (type_get_type((yyval.var)->type) != TYPE_FUNCTION) error_loc("only methods may be declared inside the methods section of a dispinterface\n"); check_function_attrs((yyval.var)->name, (yyval.var)->attrs); - ;} + } break; case 242: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 754 "parser.y" { (yyval.var) = declare_var((yyvsp[(1) - (3)].attr_list), (yyvsp[(2) - (3)].declspec), (yyvsp[(3) - (3)].declarator), FALSE); free((yyvsp[(3) - (3)].declarator)); - ;} + } break; case 243: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 757 "parser.y" { (yyval.var) = declare_var(NULL, (yyvsp[(1) - (2)].declspec), (yyvsp[(2) - (2)].declarator), FALSE); free((yyvsp[(2) - (2)].declarator)); - ;} + } break; case 244: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 762 "parser.y" - { (yyval.var) = NULL; ;} + { (yyval.var) = NULL; } break; case 246: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 766 "parser.y" - { (yyval.str) = NULL; ;} + { (yyval.str) = NULL; } break; case 247: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 767 "parser.y" - { (yyval.str) = (yyvsp[(1) - (1)].str); ;} + { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 248: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 768 "parser.y" - { (yyval.str) = (yyvsp[(1) - (1)].str); ;} + { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 249: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 771 "parser.y" - { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;} + { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); } break; case 250: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 773 "parser.y" - { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); ;} + { (yyval.var) = make_var((yyvsp[(1) - (1)].str)); } break; case 251: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 776 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 252: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 777 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 254: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 779 "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 255: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 780 "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 256: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 781 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); } break; case 257: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 782 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 258: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 783 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 259: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 784 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 260: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 785 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 261: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 786 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 264: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 793 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); } break; case 265: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 794 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); } break; case 266: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 795 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); } break; case 267: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 796 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); } break; case 268: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 797 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); } break; case 269: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 798 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); } break; case 270: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 799 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); } break; case 271: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 800 "parser.y" - { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); ;} + { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); } break; case 272: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 803 "parser.y" - { (yyval.type) = type_new_coclass((yyvsp[(2) - (2)].str)); ;} + { (yyval.type) = type_new_coclass((yyvsp[(2) - (2)].str)); } break; case 273: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 804 "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", (yyvsp[(2) - (2)].str), (yyval.type)->loc_info.input_name, (yyval.type)->loc_info.line_number); - ;} + } break; case 274: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 812 "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 275: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 819 "parser.y" - { (yyval.type) = type_coclass_define((yyvsp[(1) - (5)].type), (yyvsp[(3) - (5)].ifref_list)); ;} + { (yyval.type) = type_coclass_define((yyvsp[(1) - (5)].type), (yyvsp[(3) - (5)].ifref_list)); } break; case 276: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 822 "parser.y" - { (yyval.ifref_list) = NULL; ;} + { (yyval.ifref_list) = NULL; } break; case 277: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 823 "parser.y" - { (yyval.ifref_list) = append_ifref( (yyvsp[(1) - (2)].ifref_list), (yyvsp[(2) - (2)].ifref) ); ;} + { (yyval.ifref_list) = append_ifref( (yyvsp[(1) - (2)].ifref_list), (yyvsp[(2) - (2)].ifref) ); } break; case 278: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 827 "parser.y" - { (yyval.ifref) = make_ifref((yyvsp[(2) - (2)].type)); (yyval.ifref)->attrs = (yyvsp[(1) - (2)].attr_list); ;} + { (yyval.ifref) = make_ifref((yyvsp[(2) - (2)].type)); (yyval.ifref)->attrs = (yyvsp[(1) - (2)].attr_list); } break; case 279: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 830 "parser.y" - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;} + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); } break; case 280: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 831 "parser.y" - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;} + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); } break; case 281: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 834 "parser.y" { attr_t *attrs; (yyval.type) = (yyvsp[(2) - (2)].type); @@ -4751,86 +4773,86 @@ yyreduce: attrs = make_attr(ATTR_DISPINTERFACE); (yyval.type)->attrs = append_attr( check_dispiface_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list)), attrs ); (yyval.type)->defined = TRUE; - ;} + } break; case 282: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 843 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 283: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 844 "parser.y" - { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); ;} + { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); } break; case 284: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 847 "parser.y" - { (yyval.var_list) = NULL; ;} + { (yyval.var_list) = NULL; } break; case 285: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 848 "parser.y" - { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); ;} + { (yyval.var_list) = append_var( (yyvsp[(1) - (3)].var_list), (yyvsp[(2) - (3)].var) ); } break; case 286: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 854 "parser.y" { (yyval.type) = (yyvsp[(1) - (5)].type); type_dispinterface_define((yyval.type), (yyvsp[(3) - (5)].var_list), (yyvsp[(4) - (5)].var_list)); - ;} + } break; case 287: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 858 "parser.y" { (yyval.type) = (yyvsp[(1) - (5)].type); type_dispinterface_define_from_iface((yyval.type), (yyvsp[(3) - (5)].type)); - ;} + } break; case 288: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 863 "parser.y" - { (yyval.type) = NULL; ;} + { (yyval.type) = NULL; } break; case 289: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 864 "parser.y" - { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); ;} + { (yyval.type) = find_type_or_error2((yyvsp[(2) - (2)].str), 0); } break; case 290: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 867 "parser.y" - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;} + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); } break; case 291: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 868 "parser.y" - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); ;} + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[(2) - (2)].str), 0); } break; case 292: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 871 "parser.y" { (yyval.ifinfo).interface = (yyvsp[(2) - (2)].type); (yyval.ifinfo).old_pointer_default = pointer_default; @@ -4839,622 +4861,633 @@ yyreduce: check_def((yyvsp[(2) - (2)].type)); (yyvsp[(2) - (2)].type)->attrs = check_iface_attrs((yyvsp[(2) - (2)].type)->name, (yyvsp[(1) - (2)].attr_list)); (yyvsp[(2) - (2)].type)->defined = TRUE; - ;} + } break; case 293: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 882 "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 294: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 890 "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 295: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 894 "parser.y" - { (yyval.type) = (yyvsp[(1) - (2)].type); ;} + { (yyval.type) = (yyvsp[(1) - (2)].type); } break; case 296: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 898 "parser.y" - { (yyval.type) = (yyvsp[(1) - (2)].type); ;} + { (yyval.type) = (yyvsp[(1) - (2)].type); } break; case 297: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 899 "parser.y" - { (yyval.type) = (yyvsp[(1) - (2)].type); ;} + { (yyval.type) = (yyvsp[(1) - (2)].type); } break; case 298: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 902 "parser.y" - { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;} + { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); } break; case 299: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 903 "parser.y" - { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); ;} + { (yyval.type) = type_new_module((yyvsp[(2) - (2)].str)); } break; case 300: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 906 "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 301: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 912 "parser.y" { (yyval.type) = (yyvsp[(1) - (5)].type); type_module_define((yyval.type), (yyvsp[(3) - (5)].stmt_list)); - ;} + } break; case 302: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 918 "parser.y" - { (yyval.stgclass) = STG_EXTERN; ;} + { (yyval.stgclass) = STG_EXTERN; } break; case 303: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 919 "parser.y" - { (yyval.stgclass) = STG_STATIC; ;} + { (yyval.stgclass) = STG_STATIC; } break; case 304: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 920 "parser.y" - { (yyval.stgclass) = STG_REGISTER; ;} + { (yyval.stgclass) = STG_REGISTER; } break; case 305: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 924 "parser.y" - { (yyval.attr) = make_attr(ATTR_INLINE); ;} + { (yyval.attr) = make_attr(ATTR_INLINE); } break; case 306: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 928 "parser.y" - { (yyval.attr) = make_attr(ATTR_CONST); ;} + { (yyval.attr) = make_attr(ATTR_CONST); } break; case 307: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 931 "parser.y" - { (yyval.attr_list) = NULL; ;} + { (yyval.attr_list) = NULL; } break; case 308: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 932 "parser.y" - { (yyval.attr_list) = append_attr((yyvsp[(1) - (2)].attr_list), (yyvsp[(2) - (2)].attr)); ;} + { (yyval.attr_list) = append_attr((yyvsp[(1) - (2)].attr_list), (yyvsp[(2) - (2)].attr)); } break; case 309: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 935 "parser.y" - { (yyval.declspec) = make_decl_spec((yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].declspec), NULL, NULL, STG_NONE); ;} + { (yyval.declspec) = make_decl_spec((yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].declspec), NULL, NULL, STG_NONE); } break; case 310: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 937 "parser.y" - { (yyval.declspec) = make_decl_spec((yyvsp[(2) - (3)].type), (yyvsp[(1) - (3)].declspec), (yyvsp[(3) - (3)].declspec), NULL, STG_NONE); ;} + { (yyval.declspec) = make_decl_spec((yyvsp[(2) - (3)].type), (yyvsp[(1) - (3)].declspec), (yyvsp[(3) - (3)].declspec), NULL, STG_NONE); } break; case 311: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 940 "parser.y" - { (yyval.declspec) = NULL; ;} + { (yyval.declspec) = NULL; } break; case 313: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 945 "parser.y" - { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); ;} + { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); } break; case 314: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 946 "parser.y" - { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); ;} + { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[(2) - (2)].declspec), NULL, (yyvsp[(1) - (2)].attr), STG_NONE); } break; case 315: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 947 "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, NULL, (yyvsp[(1) - (2)].stgclass)); } break; case 316: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 952 "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))); ;} + { (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 317: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 953 "parser.y" { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); - else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;} + else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); } break; case 319: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 959 "parser.y" - { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); ;} + { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); } break; case 320: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 960 "parser.y" - { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;} + { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); } break; case 321: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 961 "parser.y" - { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); } break; case 322: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 962 "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 323: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 971 "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))); ;} + { (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 324: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 972 "parser.y" { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); - else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;} + else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); } break; case 326: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 980 "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))); ;} + { (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 327: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 981 "parser.y" { (yyval.declarator) = (yyvsp[(2) - (2)].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); - else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); ;} + else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); } break; case 328: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 986 "parser.y" - { (yyval.declarator) = make_declarator(NULL); ;} + { (yyval.declarator) = make_declarator(NULL); } break; case 330: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 992 "parser.y" - { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;} + { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); } break; case 331: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 993 "parser.y" - { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); } break; case 332: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 994 "parser.y" - { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(1) - (1)].expr)); ;} + { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(1) - (1)].expr)); } break; case 333: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 996 "parser.y" { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[(2) - (3)].var_list))); (yyval.declarator)->type = NULL; - ;} + } break; case 334: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1001 "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 335: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1010 "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))); ;} + { (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 336: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1011 "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[(2) - (2)].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); } break; case 338: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1018 "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))); ;} + { (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 339: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1019 "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[(2) - (2)].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[(1) - (2)].str))); } break; case 340: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1023 "parser.y" - { (yyval.declarator) = make_declarator(NULL); ;} + { (yyval.declarator) = make_declarator(NULL); } break; case 342: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1031 "parser.y" - { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); ;} + { (yyval.declarator) = make_declarator((yyvsp[(1) - (1)].var)); } break; case 343: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1032 "parser.y" - { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); ;} + { (yyval.declarator) = (yyvsp[(2) - (3)].declarator); } break; case 344: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1033 "parser.y" - { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); ;} + { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(2) - (2)].expr)); } break; case 345: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1034 "parser.y" - { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(1) - (1)].expr)); ;} + { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[(1) - (1)].expr)); } break; case 346: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1036 "parser.y" { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[(2) - (3)].var_list))); (yyval.declarator)->type = NULL; - ;} + } break; case 347: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1041 "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 348: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1048 "parser.y" - { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[(1) - (1)].declarator) ); ;} + { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[(1) - (1)].declarator) ); } break; case 349: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1049 "parser.y" - { (yyval.declarator_list) = append_declarator( (yyvsp[(1) - (3)].declarator_list), (yyvsp[(3) - (3)].declarator) ); ;} + { (yyval.declarator_list) = append_declarator( (yyvsp[(1) - (3)].declarator_list), (yyvsp[(3) - (3)].declarator) ); } break; case 350: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1052 "parser.y" - { (yyval.expr) = NULL; ;} + { (yyval.expr) = NULL; } break; case 351: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1053 "parser.y" - { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;} + { (yyval.expr) = (yyvsp[(2) - (2)].expr); } break; case 352: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1056 "parser.y" { (yyval.declarator) = (yyvsp[(1) - (2)].declarator); (yyval.declarator)->bits = (yyvsp[(2) - (2)].expr); if (!(yyval.declarator)->bits && !(yyval.declarator)->var->name) error_loc("unnamed fields are not allowed\n"); - ;} + } break; case 353: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1063 "parser.y" - { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[(1) - (1)].declarator) ); ;} + { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[(1) - (1)].declarator) ); } break; case 354: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1065 "parser.y" - { (yyval.declarator_list) = append_declarator( (yyvsp[(1) - (3)].declarator_list), (yyvsp[(3) - (3)].declarator) ); ;} + { (yyval.declarator_list) = append_declarator( (yyvsp[(1) - (3)].declarator_list), (yyvsp[(3) - (3)].declarator) ); } break; case 355: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1069 "parser.y" - { (yyval.declarator) = (yyvsp[(1) - (1)].declarator); ;} + { (yyval.declarator) = (yyvsp[(1) - (1)].declarator); } break; case 356: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1070 "parser.y" - { (yyval.declarator) = (yyvsp[(1) - (3)].declarator); (yyvsp[(1) - (3)].declarator)->var->eval = (yyvsp[(3) - (3)].expr); ;} + { (yyval.declarator) = (yyvsp[(1) - (3)].declarator); (yyvsp[(1) - (3)].declarator)->var->eval = (yyvsp[(3) - (3)].expr); } break; case 357: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1074 "parser.y" - { (yyval.num) = THREADING_APARTMENT; ;} + { (yyval.num) = THREADING_APARTMENT; } break; case 358: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1075 "parser.y" - { (yyval.num) = THREADING_NEUTRAL; ;} + { (yyval.num) = THREADING_NEUTRAL; } break; case 359: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1076 "parser.y" - { (yyval.num) = THREADING_SINGLE; ;} + { (yyval.num) = THREADING_SINGLE; } break; case 360: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1077 "parser.y" - { (yyval.num) = THREADING_FREE; ;} + { (yyval.num) = THREADING_FREE; } break; case 361: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1078 "parser.y" - { (yyval.num) = THREADING_BOTH; ;} + { (yyval.num) = THREADING_BOTH; } break; case 362: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1082 "parser.y" - { (yyval.num) = RPC_FC_RP; ;} + { (yyval.num) = RPC_FC_RP; } break; case 363: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1083 "parser.y" - { (yyval.num) = RPC_FC_UP; ;} + { (yyval.num) = RPC_FC_UP; } break; case 364: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1084 "parser.y" - { (yyval.num) = RPC_FC_FP; ;} + { (yyval.num) = RPC_FC_FP; } break; case 365: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1087 "parser.y" - { (yyval.type) = type_new_struct((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;} + { (yyval.type) = type_new_struct((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); } break; case 366: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1090 "parser.y" - { (yyval.type) = type_new_void(); ;} + { (yyval.type) = type_new_void(); } break; case 367: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1091 "parser.y" - { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); ;} + { (yyval.type) = find_type_or_error((yyvsp[(1) - (1)].str), 0); } break; case 368: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1092 "parser.y" - { (yyval.type) = (yyvsp[(1) - (1)].type); ;} + { (yyval.type) = (yyvsp[(1) - (1)].type); } break; case 369: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1093 "parser.y" - { (yyval.type) = (yyvsp[(1) - (1)].type); ;} + { (yyval.type) = (yyvsp[(1) - (1)].type); } break; case 370: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1094 "parser.y" - { (yyval.type) = type_new_enum((yyvsp[(2) - (2)].str), FALSE, NULL); ;} + { (yyval.type) = type_new_enum((yyvsp[(2) - (2)].str), FALSE, NULL); } break; case 371: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1095 "parser.y" - { (yyval.type) = (yyvsp[(1) - (1)].type); ;} + { (yyval.type) = (yyvsp[(1) - (1)].type); } break; case 372: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1096 "parser.y" - { (yyval.type) = type_new_struct((yyvsp[(2) - (2)].str), FALSE, NULL); ;} + { (yyval.type) = type_new_struct((yyvsp[(2) - (2)].str), FALSE, NULL); } break; case 373: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1097 "parser.y" - { (yyval.type) = (yyvsp[(1) - (1)].type); ;} + { (yyval.type) = (yyvsp[(1) - (1)].type); } break; case 374: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1098 "parser.y" - { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (2)].str), FALSE, NULL); ;} + { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (2)].str), FALSE, NULL); } break; case 375: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1099 "parser.y" - { (yyval.type) = make_safearray((yyvsp[(3) - (4)].type)); ;} + { (yyval.type) = make_safearray((yyvsp[(3) - (4)].type)); } break; case 376: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1103 "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 377: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1109 "parser.y" - { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); ;} + { (yyval.type) = type_new_nonencapsulated_union((yyvsp[(2) - (5)].str), TRUE, (yyvsp[(4) - (5)].var_list)); } break; case 378: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1112 "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)); ;} + { (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 379: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1116 "parser.y" - { (yyval.num) = MAKEVERSION((yyvsp[(1) - (1)].num), 0); ;} + { (yyval.num) = MAKEVERSION((yyvsp[(1) - (1)].num), 0); } break; case 380: -/* Line 1464 of yacc.c */ +/* Line 1806 of yacc.c */ #line 1117 "parser.y" - { (yyval.num) = MAKEVERSION((yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num)); ;} + { (yyval.num) = MAKEVERSION((yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num)); } break; -/* Line 1464 of yacc.c */ -#line 5456 "parser.tab.c" +/* Line 1806 of yacc.c */ +#line 5478 "parser.tab.c" default: break; } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); YYPOPSTACK (yylen); @@ -5482,6 +5515,10 @@ yyreduce: | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { @@ -5489,37 +5526,36 @@ yyerrlab: #if ! YYERROR_VERBOSE yyerror (YY_("syntax error")); #else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) { - YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) - { - YYSIZE_T yyalloc = 2 * yysize; - if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) - { - (void) yysyntax_error (yymsg, yystate, yychar); - yyerror (yymsg); - } - else - { - yyerror (YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; } +# undef YYSYNTAX_ERROR #endif } @@ -5578,7 +5614,7 @@ yyerrlab1: for (;;) { yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) + if (!yypact_value_is_default (yyn)) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) @@ -5637,8 +5673,13 @@ yyexhaustedlab: yyreturn: if (yychar != YYEMPTY) - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval); + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } /* Do not reclaim the symbols of the rule which action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); @@ -5663,7 +5704,7 @@ yyreturn: -/* Line 1684 of yacc.c */ +/* Line 2067 of yacc.c */ #line 1120 "parser.y" @@ -5966,7 +6007,8 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl type_t *func_type = decl ? decl->func_type : NULL; type_t *type = decl_spec->type; - /* In case of a ranged type, duplicate it */ + /* In case of a range attribute, duplicate the type to keep track of + * the min/max values in the type format string */ if(is_attr(attrs, ATTR_RANGE)) type = duptype(type, 1); @@ -6154,7 +6196,8 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl for (ft = v->type; is_ptr(ft); ft = type_pointer_get_ref(ft)) ; assert(type_get_type_detect_alias(ft) == TYPE_FUNCTION); - ft->details.function->rettype = return_type; + ft->details.function->retval = make_var(xstrdup("_RetVal")); + ft->details.function->retval->type = return_type; /* move calling convention attribute, if present, from pointer nodes to * function node */ for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t)) diff --git a/reactos/tools/widl/parser.tab.h b/reactos/tools/widl/parser.tab.h index d94b58bb108..8aca8fa6a6d 100644 --- a/reactos/tools/widl/parser.tab.h +++ b/reactos/tools/widl/parser.tab.h @@ -1,9 +1,8 @@ -/* A Bison parser, made by GNU Bison 2.4.2. */ +/* A Bison parser, made by GNU Bison 2.5. */ -/* Skeleton interface for Bison's Yacc-like parsers in C +/* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software - Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -228,7 +227,7 @@ typedef union YYSTYPE { -/* Line 1685 of yacc.c */ +/* Line 2068 of yacc.c */ #line 153 "parser.y" attr_t *attr; @@ -258,8 +257,8 @@ typedef union YYSTYPE -/* Line 1685 of yacc.c */ -#line 263 "parser.tab.h" +/* Line 2068 of yacc.c */ +#line 262 "parser.tab.h" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ diff --git a/reactos/tools/widl/parser.y b/reactos/tools/widl/parser.y index a88d344240c..03543838275 100644 --- a/reactos/tools/widl/parser.y +++ b/reactos/tools/widl/parser.y @@ -1607,7 +1607,8 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl for (ft = v->type; is_ptr(ft); ft = type_pointer_get_ref(ft)) ; assert(type_get_type_detect_alias(ft) == TYPE_FUNCTION); - ft->details.function->rettype = return_type; + ft->details.function->retval = make_var(xstrdup("_RetVal")); + ft->details.function->retval->type = return_type; /* move calling convention attribute, if present, from pointer nodes to * function node */ for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t)) diff --git a/reactos/tools/widl/parser.yy.c b/reactos/tools/widl/parser.yy.c index 1b7041fafe9..f7904240587 100644 --- a/reactos/tools/widl/parser.yy.c +++ b/reactos/tools/widl/parser.yy.c @@ -73,6 +73,7 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -103,8 +104,6 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif -#endif /* ! C99 */ - #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -161,15 +160,7 @@ typedef unsigned int flex_uint32_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else #define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -750,7 +741,7 @@ UUID *parse_uuid(const char *u) * The flexer starts here ************************************************************************** */ -#line 754 "parser.yy.c" +#line 745 "parser.yy.c" #define INITIAL 0 #define QUOTE 1 @@ -842,12 +833,7 @@ static int input (void ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else #define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -855,7 +841,7 @@ static int input (void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( parser_text, parser_leng, 1, parser_out )) {} } while (0) +#define ECHO fwrite( parser_text, parser_leng, 1, parser_out ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -866,7 +852,7 @@ static int input (void ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ + int n; \ for ( n = 0; n < max_size && \ (c = getc( parser_in )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -953,7 +939,7 @@ YY_DECL #line 127 "parser.l" -#line 957 "parser.yy.c" +#line 943 "parser.yy.c" if ( !(yy_init) ) { @@ -1268,7 +1254,7 @@ YY_RULE_SETUP #line 209 "parser.l" ECHO; YY_BREAK -#line 1272 "parser.yy.c" +#line 1258 "parser.yy.c" case YY_END_OF_BUFFER: { @@ -1987,8 +1973,8 @@ YY_BUFFER_STATE parser__scan_string (yyconst char * yystr ) /** Setup the input buffer state to scan the given bytes. The next call to parser_lex() will * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ diff --git a/reactos/tools/widl/proxy.c b/reactos/tools/widl/proxy.c index 0d78f4a299d..3ec4201a016 100644 --- a/reactos/tools/widl/proxy.c +++ b/reactos/tools/widl/proxy.c @@ -148,7 +148,7 @@ static int need_delegation_indirect(const type_t *iface) static void free_variable( const var_t *arg, const char *local_var_prefix ) { - unsigned int type_offset = arg->type->typestring_offset; + unsigned int type_offset = arg->typestring_offset; type_t *type = arg->type; write_parameter_conf_or_var_exprs(proxy, indent, local_var_prefix, PHASE_FREE, arg, FALSE); @@ -193,8 +193,8 @@ static void proxy_free_variables( var_list_t *args, const char *local_var_prefix static void gen_proxy(type_t *iface, const var_t *func, int idx, unsigned int proc_offset) { - type_t *rettype = type_function_get_rettype(func->type); - int has_ret = !is_void(rettype); + var_t *retval = type_function_get_retval(func->type); + int has_ret = !is_void(retval->type); int has_full_pointer = is_full_pointer_function(func); const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV); const var_list_t *args = type_get_function_args(func->type); @@ -204,7 +204,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, if (is_interpreted_func( iface, func )) { if (get_stub_mode() == MODE_Oif && !is_callas( func->attrs )) return; - write_type_decl_left(proxy, type_function_get_rettype(func->type)); + write_type_decl_left(proxy, retval->type); print_proxy( " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func)); write_args(proxy, args, iface->name, 1, TRUE); print_proxy( ")\n"); @@ -221,7 +221,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, print_proxy( "}\n"); print_proxy( "\n"); - write_type_decl_left(proxy, rettype); + write_type_decl_left(proxy, retval->type); print_proxy( " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func)); write_args(proxy, args, iface->name, 1, TRUE); print_proxy( ")\n"); @@ -231,14 +231,13 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, /* local variables */ if (has_ret) { print_proxy( "%s", "" ); - write_type_decl_left(proxy, rettype); - print_proxy( " _RetVal;\n"); + write_type_decl(proxy, retval->type, retval->name); + fprintf( proxy, ";\n" ); } print_proxy( "RPC_MESSAGE _RpcMessage;\n" ); if (has_ret) { - if (decl_indirect(rettype)) - print_proxy("void *_p_%s = &%s;\n", - "_RetVal", "_RetVal"); + if (decl_indirect(retval->type)) + print_proxy("void *_p_%s = &%s;\n", retval->name, retval->name); } print_proxy( "\n"); @@ -282,10 +281,10 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, if (has_ret) { - if (decl_indirect(rettype)) - print_proxy("MIDL_memset(&%s, 0, sizeof(%s));\n", "_RetVal", "_RetVal"); - else if (is_ptr(rettype) || is_array(rettype)) - print_proxy("%s = 0;\n", "_RetVal"); + if (decl_indirect(retval->type)) + print_proxy("MIDL_memset(&%s, 0, sizeof(%s));\n", retval->name, retval->name); + else if (is_ptr(retval->type) || is_array(retval->type)) + print_proxy("%s = 0;\n", retval->name); write_remoting_arguments(proxy, indent, func, "", PASS_RETURN, PHASE_UNMARSHAL); } @@ -763,12 +762,7 @@ static int does_any_iface(const statement_list_t *stmts, type_pred_t pred) if (stmts) LIST_FOR_EACH_ENTRY(stmt, stmts, const statement_t, entry) { - if (stmt->type == STMT_LIBRARY) - { - if (does_any_iface(stmt->u.lib->stmts, pred)) - return TRUE; - } - else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) + if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) { if (pred(stmt->u.type)) return TRUE; @@ -782,7 +776,6 @@ int need_proxy(const type_t *iface) { if (!is_object( iface )) return 0; if (is_local( iface->attrs )) return 0; - if (is_attr( iface->attrs, ATTR_OLEAUTOMATION )) return 0; if (is_attr( iface->attrs, ATTR_DISPINTERFACE )) return 0; return 1; } @@ -843,9 +836,7 @@ static void write_proxy_stmts(const statement_list_t *stmts, unsigned int *proc_ const statement_t *stmt; if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) { - if (stmt->type == STMT_LIBRARY) - write_proxy_stmts(stmt->u.lib->stmts, proc_offset); - else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) + if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) { if (need_proxy(stmt->u.type)) write_proxy(stmt->u.type, proc_offset); @@ -869,9 +860,7 @@ static void build_iface_list( const statement_list_t *stmts, type_t **ifaces[], if (!stmts) return; LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) { - if (stmt->type == STMT_LIBRARY) - build_iface_list(stmt->u.lib->stmts, ifaces, count); - else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) + if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) { type_t *iface = stmt->u.type; if (type_iface_get_inherit(iface) && need_proxy(iface)) diff --git a/reactos/tools/widl/server.c b/reactos/tools/widl/server.c index 3a8810e05e6..7f817b0009c 100644 --- a/reactos/tools/widl/server.c +++ b/reactos/tools/widl/server.c @@ -463,9 +463,7 @@ static void write_server_stmts(const statement_list_t *stmts, int expr_eval_rout const statement_t *stmt; if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) { - if (stmt->type == STMT_LIBRARY) - write_server_stmts(stmt->u.lib->stmts, expr_eval_routines, proc_offset); - else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) + if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) { type_t *iface = stmt->u.type; if (!need_stub(iface)) diff --git a/reactos/tools/widl/typegen.c b/reactos/tools/widl/typegen.c index 4c5f7f5b43b..74659db8e4b 100644 --- a/reactos/tools/widl/typegen.c +++ b/reactos/tools/widl/typegen.c @@ -413,12 +413,12 @@ static int get_padding(const var_list_t *fields) return ROUNDING(offset, salign); } -static unsigned int get_stack_size( const type_t *type, const attr_list_t *attrs, int *by_value ) +static unsigned int get_stack_size( const var_t *var, int *by_value ) { unsigned int stack_size; int by_val; - switch (typegen_detect_type( type, attrs, TDT_ALL_TYPES )) + switch (typegen_detect_type( var->type, var->attrs, TDT_ALL_TYPES )) { case TGT_BASIC: case TGT_ENUM: @@ -426,7 +426,7 @@ static unsigned int get_stack_size( const type_t *type, const attr_list_t *attrs case TGT_STRUCT: case TGT_UNION: case TGT_USER_TYPE: - stack_size = type_memsize( type ); + stack_size = type_memsize( var->type ); by_val = (pointer_size < 8 || stack_size <= pointer_size); /* FIXME: should be platform-specific */ break; default: @@ -899,10 +899,10 @@ static void write_var_init(FILE *file, int indent, const type_t *t, const char * void write_parameters_init(FILE *file, int indent, const var_t *func, const char *local_var_prefix) { - const var_t *var; + const var_t *var = type_function_get_retval(func->type); - if (!is_void(type_function_get_rettype(func->type))) - write_var_init(file, indent, type_function_get_rettype(func->type), "_RetVal", local_var_prefix); + if (!is_void(var->type)) + write_var_init(file, indent, var->type, var->name, local_var_prefix); if (!type_get_function_args(func->type)) return; @@ -952,35 +952,34 @@ int decl_indirect(const type_t *t) type_get_type(t) != TYPE_ARRAY); } -static unsigned char get_parameter_fc( const type_t *type, const attr_list_t *attrs, int is_return, - unsigned short *flags, unsigned int *stack_size, - unsigned int *typestring_offset ) +static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned short *flags, + unsigned int *stack_size, unsigned int *typestring_offset ) { unsigned int alignment, server_size = 0, buffer_size = 0; unsigned char fc = 0; int is_byval; - int is_in = is_attr(attrs, ATTR_IN); - int is_out = is_attr(attrs, ATTR_OUT); + int is_in = is_attr(var->attrs, ATTR_IN); + int is_out = is_attr(var->attrs, ATTR_OUT); if (is_return) is_out = TRUE; else if (!is_in && !is_out) is_in = TRUE; *flags = 0; - *stack_size = get_stack_size( type, attrs, &is_byval ); - *typestring_offset = type->typestring_offset; + *stack_size = get_stack_size( var, &is_byval ); + *typestring_offset = var->typestring_offset; if (is_in) *flags |= IsIn; if (is_out) *flags |= IsOut; if (is_return) *flags |= IsReturn; - if (!is_string_type( attrs, type )) - buffer_size = get_required_buffer_size_type( type, NULL, attrs, TRUE, &alignment ); + if (!is_string_type( var->attrs, var->type )) + buffer_size = get_required_buffer_size_type( var->type, NULL, var->attrs, TRUE, &alignment ); - switch (typegen_detect_type( type, attrs, TDT_ALL_TYPES )) + switch (typegen_detect_type( var->type, var->attrs, TDT_ALL_TYPES )) { case TGT_BASIC: *flags |= IsBasetype; - fc = get_basic_fc_signed( type ); + fc = get_basic_fc_signed( var->type ); if (fc == RPC_FC_BIND_PRIMITIVE) { buffer_size = 4; /* actually 0 but avoids setting MustSize */ @@ -989,7 +988,7 @@ static unsigned char get_parameter_fc( const type_t *type, const attr_list_t *at break; case TGT_ENUM: *flags |= IsBasetype; - fc = get_enum_fc( type ); + fc = get_enum_fc( var->type ); break; case TGT_RANGE: *flags |= IsByValue; @@ -1004,16 +1003,19 @@ static unsigned char get_parameter_fc( const type_t *type, const attr_list_t *at break; case TGT_ARRAY: *flags |= MustFree; - if (type_array_is_decl_as_ptr(type) && type->details.array.ptr_tfsoff && - get_pointer_fc( type, attrs, !is_return ) == RPC_FC_RP) + if (type_array_is_decl_as_ptr(var->type) && var->type->details.array.ptr_tfsoff && + get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) + { + *typestring_offset = var->type->typestring_offset; *flags |= IsSimpleRef; + } break; case TGT_STRING: *flags |= MustFree; - if (is_declptr( type ) && get_pointer_fc( type, attrs, !is_return ) == RPC_FC_RP) + if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) { /* skip over pointer description straight to string description */ - if (is_conformant_array( type )) *typestring_offset += 4; + if (is_conformant_array( var->type )) *typestring_offset += 4; else *typestring_offset += 2; *flags |= IsSimpleRef; } @@ -1026,11 +1028,11 @@ static unsigned char get_parameter_fc( const type_t *type, const attr_list_t *at buffer_size = 20; break; case TGT_POINTER: - if (get_pointer_fc( type, attrs, !is_return ) == RPC_FC_RP) + if (get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) { - const type_t *ref = type_pointer_get_ref( type ); + const type_t *ref = type_pointer_get_ref( var->type ); - if (!is_string_type( attrs, ref )) + if (!is_string_type( var->attrs, ref )) buffer_size = get_required_buffer_size_type( ref, NULL, NULL, TRUE, &alignment ); switch (typegen_detect_type( ref, NULL, TDT_ALL_TYPES )) @@ -1111,14 +1113,14 @@ static unsigned char get_func_oi2_flags( const var_t *func ) { const var_t *var; var_list_t *args = type_get_function_args( func->type ); - type_t *ret_type = type_function_get_rettype( func->type ); + var_t *retval = type_function_get_retval( func->type ); unsigned char oi2_flags = 0x40; /* HasExtensions */ unsigned short flags; unsigned int stack_size, typestring_offset; if (args) LIST_FOR_EACH_ENTRY( var, args, const var_t, entry ) { - get_parameter_fc( var->type, var->attrs, 0, &flags, &stack_size, &typestring_offset ); + get_parameter_fc( var, 0, &flags, &stack_size, &typestring_offset ); if (flags & MustSize) { if (flags & IsIn) oi2_flags |= 0x02; /* ClientMustSize */ @@ -1126,24 +1128,22 @@ static unsigned char get_func_oi2_flags( const var_t *func ) } } - if (!is_void( ret_type )) + if (!is_void( retval->type )) { oi2_flags |= 0x04; /* HasRet */ - get_parameter_fc( ret_type, NULL, 1, &flags, &stack_size, &typestring_offset ); + get_parameter_fc( retval, 1, &flags, &stack_size, &typestring_offset ); if (flags & MustSize) oi2_flags |= 0x01; /* ServerMustSize */ } return oi2_flags; } -static unsigned int write_new_procformatstring_type(FILE *file, int indent, - const type_t *type, - const attr_list_t *attrs, +static unsigned int write_new_procformatstring_type(FILE *file, int indent, const var_t *var, int is_return, unsigned int *stack_offset) { char buffer[64]; unsigned int stack_size, typestring_offset; unsigned short flags; - unsigned char fc = get_parameter_fc( type, attrs, is_return, &flags, &stack_size, &typestring_offset ); + unsigned char fc = get_parameter_fc( var, is_return, &flags, &stack_size, &typestring_offset ); strcpy( buffer, "/* flags:" ); if (flags & MustSize) strcat( buffer, " must size," ); @@ -1172,20 +1172,18 @@ static unsigned int write_new_procformatstring_type(FILE *file, int indent, return 6; } -static unsigned int write_old_procformatstring_type(FILE *file, int indent, - const type_t *type, - const attr_list_t *attrs, +static unsigned int write_old_procformatstring_type(FILE *file, int indent, const var_t *var, int is_return, int is_interpreted) { unsigned int size; - int is_in = is_attr(attrs, ATTR_IN); - int is_out = is_attr(attrs, ATTR_OUT); + int is_in = is_attr(var->attrs, ATTR_IN); + int is_out = is_attr(var->attrs, ATTR_OUT); if (!is_in && !is_out) is_in = TRUE; - if (type_get_type(type) == TYPE_BASIC || - type_get_type(type) == TYPE_ENUM) + if (type_get_type(var->type) == TYPE_BASIC || + type_get_type(var->type) == TYPE_ENUM) { unsigned char fc; @@ -1194,13 +1192,13 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, else print_file(file, indent, "0x4e, /* FC_IN_PARAM_BASETYPE */\n"); - if (type_get_type(type) == TYPE_ENUM) + if (type_get_type(var->type) == TYPE_ENUM) { - fc = get_enum_fc(type); + fc = get_enum_fc(var->type); } else { - fc = get_basic_fc_signed(type); + fc = get_basic_fc_signed(var->type); if (fc == RPC_FC_BIND_PRIMITIVE) fc = RPC_FC_IGNORE; @@ -1212,12 +1210,12 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, } else { - unsigned short offset = type->typestring_offset; + unsigned short offset = var->typestring_offset; - if (is_interpreted && is_array(type) && - type_array_is_decl_as_ptr(type) && - type->details.array.ptr_tfsoff) - offset = type->details.array.ptr_tfsoff; + if (!is_interpreted && is_array(var->type) && + type_array_is_decl_as_ptr(var->type) && + var->type->details.array.ptr_tfsoff) + offset = var->type->typestring_offset; if (is_return) print_file(file, indent, "0x52, /* FC_RETURN_PARAM */\n"); @@ -1228,7 +1226,7 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, else print_file(file, indent, "0x4d, /* FC_IN_PARAM */\n"); - size = get_stack_size( type, attrs, NULL ); + size = get_stack_size( var, NULL ); print_file(file, indent, "0x%02x,\n", size / pointer_size ); print_file(file, indent, "NdrFcShort(0x%x), /* type offset = %u */\n", offset, offset); size = 4; /* includes param type prefix */ @@ -1318,7 +1316,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, handle_stack_offset = stack_size; handle_param_num = param_num; } - stack_size += get_stack_size( var->type, var->attrs, NULL ); + stack_size += get_stack_size( var, NULL ); param_num++; nb_args++; } @@ -1425,6 +1423,7 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i unsigned int stack_offset = is_object( iface ) ? pointer_size : 0; int is_interpreted = is_interpreted_func( iface, func ); int is_new_style = is_interpreted && (get_stub_mode() == MODE_Oif); + var_t *retval = type_function_get_retval( func->type ); if (is_interpreted) write_proc_func_header( file, indent, iface, func, offset, num_proc ); @@ -1436,16 +1435,14 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i { print_file( file, 0, "/* %u (parameter %s) */\n", *offset, var->name ); if (is_new_style) - *offset += write_new_procformatstring_type(file, indent, var->type, var->attrs, - FALSE, &stack_offset); + *offset += write_new_procformatstring_type(file, indent, var, FALSE, &stack_offset); else - *offset += write_old_procformatstring_type(file, indent, var->type, var->attrs, - FALSE, is_interpreted); + *offset += write_old_procformatstring_type(file, indent, var, FALSE, is_interpreted); } } /* emit return value data */ - if (is_void(type_function_get_rettype(func->type))) + if (is_void(retval->type)) { if (!is_new_style) { @@ -1459,11 +1456,9 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i { print_file( file, 0, "/* %u (return value) */\n", *offset ); if (is_new_style) - *offset += write_new_procformatstring_type(file, indent, type_function_get_rettype(func->type), - NULL, TRUE, &stack_offset); + *offset += write_new_procformatstring_type(file, indent, retval, TRUE, &stack_offset); else - *offset += write_old_procformatstring_type(file, indent, type_function_get_rettype(func->type), - NULL, TRUE, is_interpreted); + *offset += write_old_procformatstring_type(file, indent, retval, TRUE, is_interpreted); } } @@ -1488,8 +1483,6 @@ static void write_procformatstring_stmts(FILE *file, int indent, const statement write_procformatstring_func( file, indent, iface, func, offset, count++ ); } } - else if (stmt->type == STMT_LIBRARY) - write_procformatstring_stmts(file, indent, stmt->u.lib->stmts, pred, offset); } } @@ -1661,7 +1654,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, correlation_variable = var->type; break; } - offset += get_stack_size( var->type, var->attrs, NULL ); + offset += get_stack_size( var, NULL ); } } else @@ -2338,6 +2331,11 @@ static void write_array_element_type(FILE *file, const type_t *type, ref->typestring_offset, tfsoff); return; } + if (cont_is_complex && is_string_type(NULL, elem)) + { + write_string_tfs(file, NULL, elem, TYPE_CONTEXT_CONTAINER, NULL, tfsoff); + return; + } if (!is_string_type(NULL, elem) && (type_get_type(ref) == TYPE_BASIC || type_get_type(ref) == TYPE_ENUM)) { @@ -2382,8 +2380,8 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff) print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", RPC_FC_LONG); write_conf_or_var_desc(file, current_structure, offset, ft, get_attrp(f->attrs, ATTR_SWITCHIS)); - print_file(file, 2, "NdrFcShort(%hd),\t/* Offset= %hd (%u) */\n", - reloff, reloff, absoff); + print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", + (unsigned short)reloff, reloff, absoff); *tfsoff += 8; } offset += size; @@ -3617,7 +3615,7 @@ static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *ty static unsigned int process_tfs_stmts(FILE *file, const statement_list_t *stmts, type_pred_t pred, unsigned int *typeformat_offset) { - const var_t *var; + var_t *var; const statement_t *stmt; if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) @@ -3625,12 +3623,7 @@ static unsigned int process_tfs_stmts(FILE *file, const statement_list_t *stmts, const type_t *iface; const statement_t *stmt_func; - if (stmt->type == STMT_LIBRARY) - { - process_tfs_stmts(file, stmt->u.lib->stmts, pred, typeformat_offset); - continue; - } - else if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) + if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) continue; iface = stmt->u.type; @@ -3644,16 +3637,16 @@ static unsigned int process_tfs_stmts(FILE *file, const statement_list_t *stmts, current_func = func; if (is_local(func->attrs)) continue; - if (!is_void(type_function_get_rettype(func->type))) - { - write_type_tfs( file, 2, func->attrs, type_function_get_rettype(func->type), - func->name, TYPE_CONTEXT_PARAM, typeformat_offset); - } + var = type_function_get_retval(func->type); + if (!is_void(var->type)) + var->typestring_offset = write_type_tfs( file, 2, func->attrs, var->type, func->name, + TYPE_CONTEXT_PARAM, typeformat_offset); if (type_get_function_args(func->type)) - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) - write_type_tfs( file, 2, var->attrs, var->type, var->name, - TYPE_CONTEXT_TOPLEVELPARAM, typeformat_offset ); + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), var_t, entry ) + var->typestring_offset = write_type_tfs( file, 2, var->attrs, var->type, var->name, + TYPE_CONTEXT_TOPLEVELPARAM, + typeformat_offset ); } } @@ -4476,12 +4469,8 @@ void write_remoting_arguments(FILE *file, int indent, const var_t *func, const c if (pass == PASS_RETURN) { - var_t var; - var = *func; - var.type = type_function_get_rettype(func->type); - var.name = xstrdup( "_RetVal" ); - write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, &var ); - free( var.name ); + write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, + type_function_get_retval(func->type) ); } else { @@ -4511,12 +4500,7 @@ unsigned int get_size_procformatstring(const statement_list_t *stmts, type_pred_ const type_t *iface; const statement_t *stmt_func; - if (stmt->type == STMT_LIBRARY) - { - size += get_size_procformatstring(stmt->u.lib->stmts, pred) - 1; - continue; - } - else if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) + if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) continue; iface = stmt->u.type; @@ -4543,14 +4527,14 @@ void declare_stub_args( FILE *file, int indent, const var_t *func ) { int in_attr, out_attr; int i = 0; - const var_t *var; + const var_t *var = type_function_get_retval(func->type); - /* declare return value '_RetVal' */ - if (!is_void(type_function_get_rettype(func->type))) + /* declare return value */ + if (!is_void(var->type)) { print_file(file, indent, "%s", ""); - write_type_decl_left(file, type_function_get_rettype(func->type)); - fprintf(file, " _RetVal;\n"); + write_type_decl(file, var->type, var->name); + fprintf(file, ";\n"); } if (!type_get_function_args(func->type)) @@ -4605,6 +4589,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char int in_attr, out_attr; int i = 0, sep = 0; const var_t *var; + type_t *ref; if (!type_get_function_args(func->type)) return; @@ -4626,7 +4611,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char fprintf(file, " = NdrContextHandleInitialize(\n"); print_file(file, indent + 1, "&__frame->_StubMsg,\n"); print_file(file, indent + 1, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]);\n", - var->type->typestring_offset); + var->typestring_offset); break; case TGT_ARRAY: if (type_array_has_conformance(var->type)) @@ -4663,7 +4648,8 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char break; case TGT_POINTER: fprintf(file, " = &%s_W%u;\n", local_var_prefix, i); - switch (typegen_detect_type(type_pointer_get_ref(var->type), var->attrs, TDT_IGNORE_STRINGS)) + ref = type_pointer_get_ref(var->type); + switch (typegen_detect_type(ref, var->attrs, TDT_IGNORE_STRINGS)) { case TGT_BASIC: case TGT_ENUM: @@ -4676,9 +4662,20 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char print_file(file, indent, "memset(&%s_W%u, 0, sizeof(%s_W%u));\n", local_var_prefix, i, local_var_prefix, i); break; + case TGT_ARRAY: + if (type_array_is_decl_as_ptr(ref)) + { + print_file(file, indent, "%s_W%u = 0;\n", local_var_prefix, i); + break; + } + ref = type_array_get_element(ref); + /* fall through */ case TGT_STRUCT: case TGT_UNION: - case TGT_ARRAY: + if (type_has_pointers(ref)) + print_file(file, indent, "memset(&%s_W%u, 0, sizeof(%s_W%u));\n", + local_var_prefix, i, local_var_prefix, i); + break; case TGT_CTXT_HANDLE: case TGT_CTXT_HANDLE_POINTER: case TGT_INVALID: @@ -4703,7 +4700,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char void write_func_param_struct( FILE *file, const type_t *iface, const type_t *func, const char *var_decl, int add_retval ) { - type_t *rettype = type_function_get_rettype( func ); + var_t *retval = type_function_get_retval( func ); const var_list_t *args = type_get_function_args( func ); const var_t *arg; int needs_packing; @@ -4737,11 +4734,12 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun else fprintf( file, "DECLSPEC_ALIGN(%u) %s;\n", pointer_size, arg->name ); } - if (add_retval && !is_void( rettype )) + if (add_retval && !is_void( retval->type )) { print_file(file, 2, "%s", ""); - write_type_decl( file, rettype, "_RetVal" ); - if (is_array( rettype ) || is_ptr( rettype ) || type_memsize( rettype ) == pointer_size) + write_type_decl( file, retval->type, retval->name ); + if (is_array( retval->type ) || is_ptr( retval->type ) || + type_memsize( retval->type ) == pointer_size) fprintf( file, ";\n" ); else fprintf( file, " DECLSPEC_ALIGN(%u);\n", pointer_size ); diff --git a/reactos/tools/widl/typetree.h b/reactos/tools/widl/typetree.h index 8b19739f33a..1e7ed88951a 100644 --- a/reactos/tools/widl/typetree.h +++ b/reactos/tools/widl/typetree.h @@ -92,11 +92,16 @@ static inline var_list_t *type_function_get_args(const type_t *type) return type->details.function->args; } -static inline type_t *type_function_get_rettype(const type_t *type) +static inline var_t *type_function_get_retval(const type_t *type) { type = type_get_real_type(type); assert(type_get_type(type) == TYPE_FUNCTION); - return type->details.function->rettype; + return type->details.function->retval; +} + +static inline type_t *type_function_get_rettype(const type_t *type) +{ + return type_function_get_retval(type)->type; } static inline var_list_t *type_enum_get_values(const type_t *type) diff --git a/reactos/tools/widl/widltypes.h b/reactos/tools/widl/widltypes.h index d3471e89d78..8447a15ba7f 100644 --- a/reactos/tools/widl/widltypes.h +++ b/reactos/tools/widl/widltypes.h @@ -338,7 +338,7 @@ struct enumeration_details struct func_details { var_list_t *args; - struct _type_t *rettype; + struct _var_t *retval; int idx; }; @@ -445,6 +445,7 @@ struct _var_t { expr_t *eval; enum storage_class stgclass; unsigned int procstring_offset; + unsigned int typestring_offset; struct _loc_info_t loc_info;