From 22c8b4bf12419daec8151c9e246db7ce5ce8deec Mon Sep 17 00:00:00 2001 From: Amine Khaldi Date: Tue, 29 Jan 2019 13:18:09 +0100 Subject: [PATCH] [WIDL] Sync with Wine Staging 4.0. CORE-15682 --- CMakeLists.txt | 2 +- media/doc/README.WINE | 2 +- sdk/include/host/ndrtypes.h | 1 + sdk/tools/widl/client.c | 153 +- sdk/tools/widl/expr.c | 8 +- sdk/tools/widl/header.c | 127 +- sdk/tools/widl/header.h | 3 +- sdk/tools/widl/parser.l | 46 +- sdk/tools/widl/parser.tab.c | 5360 ++++++++++++++++++----------------- sdk/tools/widl/parser.tab.h | 359 +-- sdk/tools/widl/parser.y | 339 ++- sdk/tools/widl/parser.yy.c | 140 +- sdk/tools/widl/parser.yy.h | 2 +- sdk/tools/widl/proxy.c | 81 +- sdk/tools/widl/register.c | 47 +- sdk/tools/widl/server.c | 24 +- sdk/tools/widl/typegen.c | 993 ++++--- sdk/tools/widl/typegen.h | 1 + sdk/tools/widl/typelib.c | 20 +- sdk/tools/widl/typelib.h | 4 + sdk/tools/widl/typetree.c | 17 +- sdk/tools/widl/typetree.h | 7 + sdk/tools/widl/widl.c | 123 +- sdk/tools/widl/widl.h | 13 +- sdk/tools/widl/widltypes.h | 8 +- sdk/tools/widl/write_msft.c | 350 ++- sdk/tools/widl/write_sltg.c | 7 +- 27 files changed, 4502 insertions(+), 3735 deletions(-) create mode 100644 sdk/include/host/ndrtypes.h diff --git a/CMakeLists.txt b/CMakeLists.txt index c931d018dac..ae26227eeb5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -83,7 +83,7 @@ if(NOT CMAKE_CROSSCOMPILING) if(MSVC) if(ARCH STREQUAL "i386") - add_definitions(/D_X86_ /DWIN32 /D_WINDOWS) + add_definitions(/D_X86_ /D__i386__ /DWIN32 /D_WINDOWS) endif() if(MSVC_VERSION GREATER 1699) add_definitions(/D_ALLOW_KEYWORD_MACROS) diff --git a/media/doc/README.WINE b/media/doc/README.WINE index 3a4fd476f00..f31f2105ac4 100644 --- a/media/doc/README.WINE +++ b/media/doc/README.WINE @@ -16,7 +16,7 @@ wine-patches@winehq.com and ros-dev@reactos.org The following build tools are shared with Wine. reactos/sdk/tools/unicode # Synced to WineStaging-3.3 -reactos/sdk/tools/widl # Synced to WineStaging-3.3 +reactos/sdk/tools/widl # Synced to WineStaging-4.0 reactos/sdk/tools/wpp # Synced to WineStaging-2.9 The following libraries are shared with Wine. diff --git a/sdk/include/host/ndrtypes.h b/sdk/include/host/ndrtypes.h new file mode 100644 index 00000000000..c7be4f69e24 --- /dev/null +++ b/sdk/include/host/ndrtypes.h @@ -0,0 +1 @@ +#include "../psdk/ndrtypes.h" diff --git a/sdk/tools/widl/client.c b/sdk/tools/widl/client.c index 739dba9c913..30b0dce5b8a 100644 --- a/sdk/tools/widl/client.c +++ b/sdk/tools/widl/client.c @@ -91,7 +91,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, print_client("MIDL_STUB_MESSAGE _StubMsg;\n"); if (handle_var) { - if (explicit_fc == RPC_FC_BIND_GENERIC) + if (explicit_fc == FC_BIND_GENERIC) print_client("%s %s;\n", get_explicit_generic_handle_type(handle_var)->name, handle_var->name ); print_client("RPC_BINDING_HANDLE _Handle;\n"); @@ -113,7 +113,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, print_client("NdrFreeBuffer(&__frame->_StubMsg);\n"); - if (explicit_fc == RPC_FC_BIND_GENERIC) + if (explicit_fc == FC_BIND_GENERIC) { fprintf(client, "\n"); print_client("if (__frame->_Handle)\n"); @@ -144,7 +144,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, if (handle_var) { print_client( "__frame->_Handle = 0;\n" ); - if (explicit_fc == RPC_FC_BIND_GENERIC) + if (explicit_fc == FC_BIND_GENERIC) print_client("__frame->%s = %s;\n", handle_var->name, handle_var->name ); } if (has_ret && decl_indirect(retval->type)) @@ -180,16 +180,16 @@ static void write_function_stub( const type_t *iface, const var_t *func, switch (explicit_fc) { - case RPC_FC_BIND_PRIMITIVE: + case FC_BIND_PRIMITIVE: print_client("__frame->_Handle = %s;\n", handle_var->name); fprintf(client, "\n"); break; - case RPC_FC_BIND_GENERIC: + case FC_BIND_GENERIC: print_client("__frame->_Handle = %s_bind(%s);\n", get_explicit_generic_handle_type(handle_var)->name, handle_var->name); fprintf(client, "\n"); break; - case RPC_FC_BIND_CONTEXT: + case FC_BIND_CONTEXT: { /* if the context_handle attribute appears in the chain of types * without pointers being followed, then the context handle must @@ -287,6 +287,68 @@ static void write_function_stub( const type_t *iface, const var_t *func, fprintf(client, "\n"); } +static void write_serialize_function(FILE *file, const type_t *type, const type_t *iface, + const char *func_name, const char *ret_type) +{ + enum stub_mode mode = get_stub_mode(); + static int emited_pickling_info; + + if (iface && !type->typestring_offset) + { + /* FIXME: Those are mostly basic types. They should be implemented + * using NdrMesSimpleType* functions */ + if (ret_type) warning("Serialization of type %s is not supported\n", type->name); + return; + } + + if (!emited_pickling_info && iface && mode != MODE_Os) + { + fprintf(file, "static const MIDL_TYPE_PICKLING_INFO __MIDL_TypePicklingInfo =\n"); + fprintf(file, "{\n"); + fprintf(file, " 0x33205054,\n"); + fprintf(file, " 0x3,\n"); + fprintf(file, " 0,\n"); + fprintf(file, " 0,\n"); + fprintf(file, " 0\n"); + fprintf(file, "};\n"); + fprintf(file, "\n"); + emited_pickling_info = 1; + } + + /* FIXME: Assuming explicit handle */ + + fprintf(file, "%s __cdecl %s_%s(handle_t IDL_handle, %s *IDL_type)%s\n", + ret_type ? ret_type : "void", type->name, func_name, type->name, iface ? "" : ";"); + if (!iface) return; /* declaration only */ + + fprintf(file, "{\n"); + fprintf(file, " %sNdrMesType%s%s(\n", ret_type ? "return " : "", func_name, + mode != MODE_Os ? "2" : ""); + fprintf(file, " IDL_handle,\n"); + if (mode != MODE_Os) + fprintf(file, " (MIDL_TYPE_PICKLING_INFO*)&__MIDL_TypePicklingInfo,\n"); + fprintf(file, " &%s_StubDesc,\n", iface->name); + fprintf(file, " (PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%u],\n", + type->typestring_offset); + fprintf(file, " IDL_type);\n"); + fprintf(file, "}\n"); + fprintf(file, "\n"); +} + +void write_serialize_functions(FILE *file, const type_t *type, const type_t *iface) +{ + if (is_attr(type->attrs, ATTR_ENCODE)) + { + write_serialize_function(file, type, iface, "AlignSize", "SIZE_T"); + write_serialize_function(file, type, iface, "Encode", NULL); + } + if (is_attr(type->attrs, ATTR_DECODE)) + { + write_serialize_function(file, type, iface, "Decode", NULL); + write_serialize_function(file, type, iface, "Free", NULL); + } +} + static void write_function_stubs(type_t *iface, unsigned int *proc_offset) { const statement_t *stmt; @@ -296,11 +358,30 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset) if (!implicit_handle) print_client("static RPC_BINDING_HANDLE %s__MIDL_AutoBindHandle;\n\n", iface->name); - STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) + LIST_FOR_EACH_ENTRY( stmt, type_iface_get_stmts(iface), const statement_t, entry ) { - const var_t *func = stmt->u.var; - write_function_stub( iface, func, method_count++, *proc_offset ); - *proc_offset += get_size_procformatstring_func( iface, func ); + switch (stmt->type) + { + case STMT_DECLARATION: + { + const var_t *func = stmt->u.var; + if (stmt->u.var->stgclass != STG_NONE + || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION) + continue; + write_function_stub( iface, func, method_count++, *proc_offset ); + *proc_offset += get_size_procformatstring_func( iface, func ); + break; + } + case STMT_TYPEDEF: + { + const type_list_t *type_entry; + for (type_entry = stmt->u.type_list; type_entry; type_entry = type_entry->next) + write_serialize_functions(client, type_entry->type, iface); + break; + } + default: + break; + } } } @@ -438,7 +519,7 @@ static void write_client_ifaces(const statement_list_t *stmts, int expr_eval_rou { if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) { - int has_func = 0; + int needs_stub = 0; const statement_t *stmt2; type_t *iface = stmt->u.type; if (!need_stub(iface)) @@ -449,13 +530,31 @@ static void write_client_ifaces(const statement_list_t *stmts, int expr_eval_rou fprintf(client, " */\n"); fprintf(client, "\n"); - STATEMENTS_FOR_EACH_FUNC(stmt2, type_iface_get_stmts(iface)) + LIST_FOR_EACH_ENTRY(stmt2, type_iface_get_stmts(iface), const statement_t, entry) { - has_func = 1; - break; + if (stmt2->type == STMT_DECLARATION && stmt2->u.var->stgclass == STG_NONE && + type_get_type_detect_alias(stmt2->u.var->type) == TYPE_FUNCTION) + { + needs_stub = 1; + break; + } + if (stmt2->type == STMT_TYPEDEF) + { + const type_list_t *type_entry; + for (type_entry = stmt2->u.type_list; type_entry; type_entry = type_entry->next) + { + if (is_attr(type_entry->type->attrs, ATTR_ENCODE) + || is_attr(type_entry->type->attrs, ATTR_DECODE)) + { + needs_stub = 1; + break; + } + } + if (needs_stub) + break; + } } - - if (has_func) + if (needs_stub) { write_implicithandledecl(iface); @@ -528,26 +627,6 @@ void write_client(const statement_list_t *stmts) if (!client) return; - if (do_win32 && do_win64) - { - fprintf(client, "#ifndef _WIN64\n\n"); - pointer_size = 4; - write_client_routines( stmts ); - fprintf(client, "\n#else /* _WIN64 */\n\n"); - pointer_size = 8; - write_client_routines( stmts ); - fprintf(client, "\n#endif /* _WIN64 */\n"); - } - else if (do_win32) - { - pointer_size = 4; - write_client_routines( stmts ); - } - else if (do_win64) - { - pointer_size = 8; - write_client_routines( stmts ); - } - + write_client_routines( stmts ); fclose(client); } diff --git a/sdk/tools/widl/expr.c b/sdk/tools/widl/expr.c index cf97c7ea20a..2ed4aff6ad3 100644 --- a/sdk/tools/widl/expr.c +++ b/sdk/tools/widl/expr.c @@ -50,6 +50,7 @@ static int is_integer_type(const type_t *type) case TYPE_BASIC_INT64: case TYPE_BASIC_INT: case TYPE_BASIC_INT3264: + case TYPE_BASIC_LONG: case TYPE_BASIC_CHAR: case TYPE_BASIC_HYPER: case TYPE_BASIC_BYTE: @@ -82,6 +83,7 @@ static int is_signed_integer_type(const type_t *type) case TYPE_BASIC_INT64: case TYPE_BASIC_INT: case TYPE_BASIC_INT3264: + case TYPE_BASIC_LONG: return type_basic_get_sign(type) < 0; case TYPE_BASIC_CHAR: return TRUE; @@ -519,11 +521,11 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc break; case EXPR_STRLIT: result.is_temporary = TRUE; - result.type = type_new_pointer(RPC_FC_UP, type_new_int(TYPE_BASIC_CHAR, 0), NULL); + result.type = type_new_pointer(FC_UP, type_new_int(TYPE_BASIC_CHAR, 0), NULL); break; case EXPR_WSTRLIT: result.is_temporary = TRUE; - result.type = type_new_pointer(RPC_FC_UP, type_new_int(TYPE_BASIC_WCHAR, 0), NULL); + result.type = type_new_pointer(FC_UP, type_new_int(TYPE_BASIC_WCHAR, 0), NULL); break; case EXPR_CHARCONST: result.is_temporary = TRUE; @@ -573,7 +575,7 @@ static struct expression_type resolve_expression(const struct expr_loc *expr_loc expr_loc->attr ? expr_loc->attr : ""); result.is_variable = FALSE; result.is_temporary = TRUE; - result.type = type_new_pointer(RPC_FC_UP, result.type, NULL); + result.type = type_new_pointer(FC_UP, result.type, NULL); break; case EXPR_PPTR: result = resolve_expression(expr_loc, cont_type, e->ref); diff --git a/sdk/tools/widl/header.c b/sdk/tools/widl/header.c index 6493253aeef..7c607c0a965 100644 --- a/sdk/tools/widl/header.c +++ b/sdk/tools/widl/header.c @@ -285,6 +285,15 @@ int needs_space_after(type_t *t) (!is_ptr(t) && (!is_array(t) || !type_array_is_decl_as_ptr(t) || t->name))); } +static void write_pointer_left(FILE *h, type_t *ref) +{ + if (needs_space_after(ref)) + fprintf(h, " "); + if (!type_is_alias(ref) && is_array(ref) && !type_array_is_decl_as_ptr(ref)) + fprintf(h, "("); + fprintf(h, "*"); +} + void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly) { const char *name; @@ -341,10 +350,12 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly) else fprintf(h, "union %s", t->name ? t->name : ""); break; case TYPE_POINTER: + { write_type_left(h, type_pointer_get_ref(t), name_type, declonly); - fprintf(h, "%s*", needs_space_after(type_pointer_get_ref(t)) ? " " : ""); + write_pointer_left(h, type_pointer_get_ref(t)); if (is_attr(t->attrs, ATTR_CONST)) fprintf(h, "const "); break; + } case TYPE_ARRAY: if (t->name && type_array_is_decl_as_ptr(t)) fprintf(h, "%s", t->name); @@ -352,12 +363,13 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly) { write_type_left(h, type_array_get_element(t), name_type, declonly); if (type_array_is_decl_as_ptr(t)) - fprintf(h, "%s*", needs_space_after(type_array_get_element(t)) ? " " : ""); + write_pointer_left(h, type_array_get_element(t)); } break; case TYPE_BASIC: if (type_basic_get_type(t) != TYPE_BASIC_INT32 && type_basic_get_type(t) != TYPE_BASIC_INT64 && + type_basic_get_type(t) != TYPE_BASIC_LONG && type_basic_get_type(t) != TYPE_BASIC_HYPER) { if (type_basic_get_sign(t) < 0) fprintf(h, "signed "); @@ -377,6 +389,12 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly) case TYPE_BASIC_ERROR_STATUS_T: fprintf(h, "error_status_t"); break; case TYPE_BASIC_HANDLE: fprintf(h, "handle_t"); break; case TYPE_BASIC_INT32: + if (type_basic_get_sign(t) > 0) + fprintf(h, "UINT32"); + else + fprintf(h, "INT32"); + break; + case TYPE_BASIC_LONG: if (type_basic_get_sign(t) > 0) fprintf(h, "ULONG"); else @@ -419,23 +437,36 @@ void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly) void write_type_right(FILE *h, type_t *t, int is_field) { if (!h) return; + if (type_is_alias(t)) return; switch (type_get_type(t)) { case TYPE_ARRAY: - if (!type_array_is_decl_as_ptr(t)) + { + type_t *elem = type_array_get_element(t); + if (type_array_is_decl_as_ptr(t)) + { + if (!type_is_alias(elem) && is_array(elem) && !type_array_is_decl_as_ptr(elem)) + fprintf(h, ")"); + } + else { if (is_conformant_array(t)) - { fprintf(h, "[%s]", is_field ? "1" : ""); - t = type_array_get_element(t); - } - for ( ; - type_get_type(t) == TYPE_ARRAY && !type_array_is_decl_as_ptr(t); - t = type_array_get_element(t)) + else fprintf(h, "[%u]", type_array_get_dim(t)); } + write_type_right(h, elem, FALSE); break; + } + case TYPE_POINTER: + { + type_t *ref = type_pointer_get_ref(t); + if (!type_is_alias(ref) && is_array(ref) && !type_array_is_decl_as_ptr(ref)) + fprintf(h, ")"); + write_type_right(h, ref, FALSE); + break; + } case TYPE_BITFIELD: fprintf(h, " : %u", type_bitfield_get_bits(t)->cval); break; @@ -450,7 +481,6 @@ void write_type_right(FILE *h, type_t *t, int is_field) case TYPE_COCLASS: case TYPE_FUNCTION: case TYPE_INTERFACE: - case TYPE_POINTER: break; } } @@ -686,6 +716,47 @@ void check_for_additional_prototype_types(const var_list_t *list) } } +static int write_serialize_function_decl(FILE *header, const type_t *type) +{ + write_serialize_functions(header, type, NULL); + return 1; +} + +static int serializable_exists(FILE *header, const type_t *type) +{ + return 0; +} + +static int for_each_serializable(const statement_list_t *stmts, FILE *header, + int (*proc)(FILE*, const type_t*)) +{ + statement_t *stmt, *iface_stmt; + statement_list_t *iface_stmts; + const type_list_t *type_entry; + + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry ) + { + if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) + continue; + + iface_stmts = type_iface_get_stmts(stmt->u.type); + if (iface_stmts) LIST_FOR_EACH_ENTRY( iface_stmt, iface_stmts, statement_t, entry ) + { + if (iface_stmt->type != STMT_TYPEDEF) continue; + for (type_entry = iface_stmt->u.type_list; type_entry; type_entry = type_entry->next) + { + if (!is_attr(type_entry->type->attrs, ATTR_ENCODE) + && !is_attr(type_entry->type->attrs, ATTR_DECODE)) + continue; + if (!proc(header, type_entry->type)) + return 0; + } + } + } + + return 1; +} + static void write_user_types(FILE *header) { user_type_t *ut; @@ -805,17 +876,17 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func, if (!is_attr( var->attrs, ATTR_IN ) && is_attr( var->attrs, ATTR_OUT )) continue; if (type_get_type( var->type ) == TYPE_BASIC && type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) { - *explicit_fc = RPC_FC_BIND_PRIMITIVE; + *explicit_fc = FC_BIND_PRIMITIVE; return var; } if (get_explicit_generic_handle_type( var )) { - *explicit_fc = RPC_FC_BIND_GENERIC; + *explicit_fc = FC_BIND_GENERIC; return var; } if (is_context_handle( var->type )) { - *explicit_fc = RPC_FC_BIND_CONTEXT; + *explicit_fc = FC_BIND_CONTEXT; return var; } } @@ -824,13 +895,13 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func, { if (type_get_type( var->type ) == TYPE_BASIC && type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) - *implicit_fc = RPC_FC_BIND_PRIMITIVE; + *implicit_fc = FC_BIND_PRIMITIVE; else - *implicit_fc = RPC_FC_BIND_GENERIC; + *implicit_fc = FC_BIND_GENERIC; return var; } - *implicit_fc = RPC_FC_AUTO_HANDLE; + *implicit_fc = FC_AUTO_HANDLE; return NULL; } @@ -1276,7 +1347,7 @@ static void write_locals(FILE *fp, const type_t *iface, int body) if (cas) { const statement_t *stmt2 = NULL; STATEMENTS_FOR_EACH_FUNC(stmt2, type_iface_get_stmts(iface)) - if (!strcmp(stmt2->u.var->name, cas->name)) + if (!strcmp(get_name(stmt2->u.var), cas->name)) break; if (&stmt2->entry != type_iface_get_stmts(iface)) { const var_t *m = stmt2->u.var; @@ -1596,8 +1667,13 @@ static void write_forward_decls(FILE *header, const statement_list_t *stmts) case STMT_TYPE: if (type_get_type(stmt->u.type) == TYPE_INTERFACE) { - if (is_object(stmt->u.type) || is_attr(stmt->u.type->attrs, ATTR_DISPINTERFACE)) - write_forward(header, stmt->u.type); + type_t *iface = stmt->u.type; + if (is_object(iface) || is_attr(iface->attrs, ATTR_DISPINTERFACE)) + { + write_forward(header, iface); + if (iface->details.iface->async_iface) + write_forward(header, iface->details.iface->async_iface); + } } else if (type_get_type(stmt->u.type) == TYPE_COCLASS) write_coclass_forward(header, stmt->u.type); @@ -1632,12 +1708,18 @@ static void write_header_stmts(FILE *header, const statement_list_t *stmts, cons if (type_get_type(stmt->u.type) == TYPE_INTERFACE) { type_t *iface = stmt->u.type; + type_t *async_iface = iface->details.iface->async_iface; if (is_object(iface)) is_object_interface++; if (is_attr(stmt->u.type->attrs, ATTR_DISPINTERFACE) || is_object(stmt->u.type)) { write_com_interface_start(header, iface); write_header_stmts(header, type_iface_get_stmts(iface), stmt->u.type, TRUE); write_com_interface_end(header, iface); + if (async_iface) + { + write_com_interface_start(header, async_iface); + write_com_interface_end(header, async_iface); + } } else { @@ -1717,6 +1799,7 @@ void write_header(const statement_list_t *stmts) } fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION, input_name); + fprintf(header, "#ifdef _WIN32\n"); fprintf(header, "#ifndef __REQUIRED_RPCNDR_H_VERSION__\n"); fprintf(header, "#define __REQUIRED_RPCNDR_H_VERSION__ 475\n"); fprintf(header, "#endif\n\n"); @@ -1726,7 +1809,10 @@ void write_header(const statement_list_t *stmts) fprintf(header, "#endif\n\n"); fprintf(header, "#include \n" ); - fprintf(header, "#include \n\n" ); + fprintf(header, "#include \n" ); + if (!for_each_serializable(stmts, NULL, serializable_exists)) + fprintf(header, "#include \n" ); + fprintf(header, "#endif\n\n"); fprintf(header, "#ifndef COM_NO_WINDOWS_H\n"); fprintf(header, "#include \n"); @@ -1748,6 +1834,7 @@ void write_header(const statement_list_t *stmts) fprintf(header, "/* Begin additional prototypes for all interfaces */\n"); fprintf(header, "\n"); + for_each_serializable(stmts, header, write_serialize_function_decl); write_user_types(header); write_generic_handle_routines(header); write_context_handle_rundowns(header); diff --git a/sdk/tools/widl/header.h b/sdk/tools/widl/header.h index 3798af06321..0d44b4039fe 100644 --- a/sdk/tools/widl/header.h +++ b/sdk/tools/widl/header.h @@ -48,13 +48,14 @@ extern int need_proxy_delegation(const statement_list_t *stmts); extern int need_inline_stubs_file(const statement_list_t *stmts); extern const var_t *is_callas(const attr_list_t *list); extern void write_args(FILE *h, const var_list_t *arg, const char *name, int obj, int do_indent); -extern void write_array(FILE *h, array_dims_t *v, int field); extern const type_t* get_explicit_generic_handle_type(const var_t* var); extern const var_t *get_func_handle_var( const type_t *iface, const var_t *func, unsigned char *explicit_fc, unsigned char *implicit_fc ); extern int has_out_arg_or_return(const var_t *func); extern int is_const_decl(const var_t *var); +extern void write_serialize_functions(FILE *file, const type_t *type, const type_t *iface); + static inline int is_ptr(const type_t *t) { return type_get_type(t) == TYPE_POINTER; diff --git a/sdk/tools/widl/parser.l b/sdk/tools/widl/parser.l index a57ac648b8c..3cbf4ff2d2b 100644 --- a/sdk/tools/widl/parser.l +++ b/sdk/tools/widl/parser.l @@ -76,6 +76,8 @@ static int cbufalloc = 0; static int kw_token(const char *kw); static int attr_token(const char *kw); +static void switch_to_acf(void); + static warning_list_t *disabled_warnings = NULL; #define MAX_IMPORT_DEPTH 20 @@ -225,9 +227,14 @@ SAFEARRAY{ws}*/\( return tSAFEARRAY; \.\.\. return ELLIPSIS; . return yytext[0]; <> { - if (import_stack_ptr) - return aEOF; - else yyterminate(); + if (import_stack_ptr) + return aEOF; + if (acf_name) + { + switch_to_acf(); + return aACF; + } + yyterminate(); } %% @@ -250,6 +257,7 @@ static const struct keyword keywords[] = { {"TRUE", tTRUE}, {"__cdecl", tCDECL}, {"__fastcall", tFASTCALL}, + {"__int32", tINT32}, {"__int3264", tINT3264}, {"__int64", tINT64}, {"__pascal", tPASCAL}, @@ -562,6 +570,38 @@ void abort_import(void) unlink(import_stack[ptr].temp_name); } +static void switch_to_acf(void) +{ + int ptr = import_stack_ptr; + int ret, fd; + char *name; + FILE *f; + + assert(import_stack_ptr == 0); + + input_name = acf_name; + acf_name = NULL; + line_number = 1; + + name = xstrdup( "widl.XXXXXX" ); + if((fd = mkstemps( name, 0 )) == -1) + error("Could not generate a temp name from %s\n", name); + + temp_name = name; + if (!(f = fdopen(fd, "wt"))) + error("Could not open fd %s for writing\n", name); + + ret = wpp_parse(input_name, f); + fclose(f); + if (ret) exit(1); + + if((f = fopen(temp_name, "r")) == NULL) + error_loc("Unable to open %s\n", temp_name); + + import_stack[ptr].state = YY_CURRENT_BUFFER; + yy_switch_to_buffer(yy_create_buffer(f, YY_BUF_SIZE)); +} + static void warning_disable(int warning) { warning_t *warning_entry; diff --git a/sdk/tools/widl/parser.tab.c b/sdk/tools/widl/parser.tab.c index 3d52c09450d..c45e0c08053 100644 --- a/sdk/tools/widl/parser.tab.c +++ b/sdk/tools/widl/parser.tab.c @@ -111,7 +111,7 @@ #include "expr.h" #include "typetree.h" -static unsigned char pointer_default = RPC_FC_UP; +static unsigned char pointer_default = FC_UP; typedef struct list typelist_t; struct typenode { @@ -145,7 +145,7 @@ static attr_t *make_attr(enum attr_type type); static attr_t *make_attrv(enum attr_type type, unsigned int val); static attr_t *make_attrp(enum attr_type type, void *val); static expr_list_t *append_expr(expr_list_t *list, expr_t *expr); -static array_dims_t *append_array(array_dims_t *list, expr_t *expr); +static type_t *append_array(type_t *chain, expr_t *expr); static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top); static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls); static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface); @@ -155,7 +155,7 @@ static declarator_list_t *append_declarator(declarator_list_t *list, declarator_ static declarator_t *make_declarator(var_t *var); static type_t *make_safearray(type_t *type); static typelib_t *make_library(const char *name, const attr_list_t *attrs); -static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type); +static type_t *append_chain_type(type_t *chain, type_t *type); static warning_list_t *append_warning(warning_list_t *, int); static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs); @@ -186,6 +186,8 @@ const char *get_attr_display_name(enum attr_type type); static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func); static void check_def(const type_t *t); +static void check_async_uuid(type_t *iface); + static statement_t *make_statement(enum statement_type type); static statement_t *make_statement_type_decl(type_t *type); static statement_t *make_statement_reference(type_t *type); @@ -207,8 +209,12 @@ static struct namespace global_namespace = { static struct namespace *current_namespace = &global_namespace; +#ifndef __REACTOS__ +static typelib_t *current_typelib; +#endif -#line 212 "parser.tab.c" /* yacc.c:339 */ + +#line 218 "parser.tab.c" /* yacc.c:339 */ # ifndef YY_NULL # if defined __cplusplus && 201103L <= __cplusplus @@ -228,8 +234,8 @@ static struct namespace *current_namespace = &global_namespace; /* In a future release of Bison, this section will be replaced by #include "parser.tab.h". */ -#ifndef YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED -# define YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED +#ifndef YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED +# define YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 @@ -254,179 +260,181 @@ extern int parser_debug; aSQSTRING = 266, aUUID = 267, aEOF = 268, - SHL = 269, - SHR = 270, - MEMBERPTR = 271, - EQUALITY = 272, - INEQUALITY = 273, - GREATEREQUAL = 274, - LESSEQUAL = 275, - LOGICALOR = 276, - LOGICALAND = 277, - ELLIPSIS = 278, - tAGGREGATABLE = 279, - tALLOCATE = 280, - tANNOTATION = 281, - tAPPOBJECT = 282, - tASYNC = 283, - tASYNCUUID = 284, - tAUTOHANDLE = 285, - tBINDABLE = 286, - tBOOLEAN = 287, - tBROADCAST = 288, - tBYTE = 289, - tBYTECOUNT = 290, - tCALLAS = 291, - tCALLBACK = 292, - tCASE = 293, - tCDECL = 294, - tCHAR = 295, - tCOCLASS = 296, - tCODE = 297, - tCOMMSTATUS = 298, - tCONST = 299, - tCONTEXTHANDLE = 300, - tCONTEXTHANDLENOSERIALIZE = 301, - tCONTEXTHANDLESERIALIZE = 302, - tCONTROL = 303, - tCPPQUOTE = 304, - tDECODE = 305, - tDEFAULT = 306, - tDEFAULTBIND = 307, - tDEFAULTCOLLELEM = 308, - tDEFAULTVALUE = 309, - tDEFAULTVTABLE = 310, - tDISABLECONSISTENCYCHECK = 311, - tDISPLAYBIND = 312, - tDISPINTERFACE = 313, - tDLLNAME = 314, - tDOUBLE = 315, - tDUAL = 316, - tENABLEALLOCATE = 317, - tENCODE = 318, - tENDPOINT = 319, - tENTRY = 320, - tENUM = 321, - tERRORSTATUST = 322, - tEXPLICITHANDLE = 323, - tEXTERN = 324, - tFALSE = 325, - tFASTCALL = 326, - tFAULTSTATUS = 327, - tFLOAT = 328, - tFORCEALLOCATE = 329, - tHANDLE = 330, - tHANDLET = 331, - tHELPCONTEXT = 332, - tHELPFILE = 333, - tHELPSTRING = 334, - tHELPSTRINGCONTEXT = 335, - tHELPSTRINGDLL = 336, - tHIDDEN = 337, - tHYPER = 338, - tID = 339, - tIDEMPOTENT = 340, - tIGNORE = 341, - tIIDIS = 342, - tIMMEDIATEBIND = 343, - tIMPLICITHANDLE = 344, - tIMPORT = 345, - tIMPORTLIB = 346, - tIN = 347, - tIN_LINE = 348, - tINLINE = 349, - tINPUTSYNC = 350, - tINT = 351, - tINT3264 = 352, - tINT64 = 353, - tINTERFACE = 354, - tLCID = 355, - tLENGTHIS = 356, - tLIBRARY = 357, - tLICENSED = 358, - tLOCAL = 359, - tLONG = 360, - tMAYBE = 361, - tMESSAGE = 362, - tMETHODS = 363, - tMODULE = 364, - tNAMESPACE = 365, - tNOCODE = 366, - tNONBROWSABLE = 367, - tNONCREATABLE = 368, - tNONEXTENSIBLE = 369, - tNOTIFY = 370, - tNOTIFYFLAG = 371, - tNULL = 372, - tOBJECT = 373, - tODL = 374, - tOLEAUTOMATION = 375, - tOPTIMIZE = 376, - tOPTIONAL = 377, - tOUT = 378, - tPARTIALIGNORE = 379, - tPASCAL = 380, - tPOINTERDEFAULT = 381, - tPRAGMA_WARNING = 382, - tPROGID = 383, - tPROPERTIES = 384, - tPROPGET = 385, - tPROPPUT = 386, - tPROPPUTREF = 387, - tPROXY = 388, - tPTR = 389, - tPUBLIC = 390, - tRANGE = 391, - tREADONLY = 392, - tREF = 393, - tREGISTER = 394, - tREPRESENTAS = 395, - tREQUESTEDIT = 396, - tRESTRICTED = 397, - tRETVAL = 398, - tSAFEARRAY = 399, - tSHORT = 400, - tSIGNED = 401, - tSIZEIS = 402, - tSIZEOF = 403, - tSMALL = 404, - tSOURCE = 405, - tSTATIC = 406, - tSTDCALL = 407, - tSTRICTCONTEXTHANDLE = 408, - tSTRING = 409, - tSTRUCT = 410, - tSWITCH = 411, - tSWITCHIS = 412, - tSWITCHTYPE = 413, - tTHREADING = 414, - tTRANSMITAS = 415, - tTRUE = 416, - tTYPEDEF = 417, - tUIDEFAULT = 418, - tUNION = 419, - tUNIQUE = 420, - tUNSIGNED = 421, - tUSESGETLASTERROR = 422, - tUSERMARSHAL = 423, - tUUID = 424, - tV1ENUM = 425, - tVARARG = 426, - tVERSION = 427, - tVIPROGID = 428, - tVOID = 429, - tWCHAR = 430, - tWIREMARSHAL = 431, - tAPARTMENT = 432, - tNEUTRAL = 433, - tSINGLE = 434, - tFREE = 435, - tBOTH = 436, - CAST = 437, - PPTR = 438, - POS = 439, - NEG = 440, - ADDRESSOF = 441 + aACF = 269, + SHL = 270, + SHR = 271, + MEMBERPTR = 272, + EQUALITY = 273, + INEQUALITY = 274, + GREATEREQUAL = 275, + LESSEQUAL = 276, + LOGICALOR = 277, + LOGICALAND = 278, + ELLIPSIS = 279, + tAGGREGATABLE = 280, + tALLOCATE = 281, + tANNOTATION = 282, + tAPPOBJECT = 283, + tASYNC = 284, + tASYNCUUID = 285, + tAUTOHANDLE = 286, + tBINDABLE = 287, + tBOOLEAN = 288, + tBROADCAST = 289, + tBYTE = 290, + tBYTECOUNT = 291, + tCALLAS = 292, + tCALLBACK = 293, + tCASE = 294, + tCDECL = 295, + tCHAR = 296, + tCOCLASS = 297, + tCODE = 298, + tCOMMSTATUS = 299, + tCONST = 300, + tCONTEXTHANDLE = 301, + tCONTEXTHANDLENOSERIALIZE = 302, + tCONTEXTHANDLESERIALIZE = 303, + tCONTROL = 304, + tCPPQUOTE = 305, + tDECODE = 306, + tDEFAULT = 307, + tDEFAULTBIND = 308, + tDEFAULTCOLLELEM = 309, + tDEFAULTVALUE = 310, + tDEFAULTVTABLE = 311, + tDISABLECONSISTENCYCHECK = 312, + tDISPLAYBIND = 313, + tDISPINTERFACE = 314, + tDLLNAME = 315, + tDOUBLE = 316, + tDUAL = 317, + tENABLEALLOCATE = 318, + tENCODE = 319, + tENDPOINT = 320, + tENTRY = 321, + tENUM = 322, + tERRORSTATUST = 323, + tEXPLICITHANDLE = 324, + tEXTERN = 325, + tFALSE = 326, + tFASTCALL = 327, + tFAULTSTATUS = 328, + tFLOAT = 329, + tFORCEALLOCATE = 330, + tHANDLE = 331, + tHANDLET = 332, + tHELPCONTEXT = 333, + tHELPFILE = 334, + tHELPSTRING = 335, + tHELPSTRINGCONTEXT = 336, + tHELPSTRINGDLL = 337, + tHIDDEN = 338, + tHYPER = 339, + tID = 340, + tIDEMPOTENT = 341, + tIGNORE = 342, + tIIDIS = 343, + tIMMEDIATEBIND = 344, + tIMPLICITHANDLE = 345, + tIMPORT = 346, + tIMPORTLIB = 347, + tIN = 348, + tIN_LINE = 349, + tINLINE = 350, + tINPUTSYNC = 351, + tINT = 352, + tINT32 = 353, + tINT3264 = 354, + tINT64 = 355, + tINTERFACE = 356, + tLCID = 357, + tLENGTHIS = 358, + tLIBRARY = 359, + tLICENSED = 360, + tLOCAL = 361, + tLONG = 362, + tMAYBE = 363, + tMESSAGE = 364, + tMETHODS = 365, + tMODULE = 366, + tNAMESPACE = 367, + tNOCODE = 368, + tNONBROWSABLE = 369, + tNONCREATABLE = 370, + tNONEXTENSIBLE = 371, + tNOTIFY = 372, + tNOTIFYFLAG = 373, + tNULL = 374, + tOBJECT = 375, + tODL = 376, + tOLEAUTOMATION = 377, + tOPTIMIZE = 378, + tOPTIONAL = 379, + tOUT = 380, + tPARTIALIGNORE = 381, + tPASCAL = 382, + tPOINTERDEFAULT = 383, + tPRAGMA_WARNING = 384, + tPROGID = 385, + tPROPERTIES = 386, + tPROPGET = 387, + tPROPPUT = 388, + tPROPPUTREF = 389, + tPROXY = 390, + tPTR = 391, + tPUBLIC = 392, + tRANGE = 393, + tREADONLY = 394, + tREF = 395, + tREGISTER = 396, + tREPRESENTAS = 397, + tREQUESTEDIT = 398, + tRESTRICTED = 399, + tRETVAL = 400, + tSAFEARRAY = 401, + tSHORT = 402, + tSIGNED = 403, + tSIZEIS = 404, + tSIZEOF = 405, + tSMALL = 406, + tSOURCE = 407, + tSTATIC = 408, + tSTDCALL = 409, + tSTRICTCONTEXTHANDLE = 410, + tSTRING = 411, + tSTRUCT = 412, + tSWITCH = 413, + tSWITCHIS = 414, + tSWITCHTYPE = 415, + tTHREADING = 416, + tTRANSMITAS = 417, + tTRUE = 418, + tTYPEDEF = 419, + tUIDEFAULT = 420, + tUNION = 421, + tUNIQUE = 422, + tUNSIGNED = 423, + tUSESGETLASTERROR = 424, + tUSERMARSHAL = 425, + tUUID = 426, + tV1ENUM = 427, + tVARARG = 428, + tVERSION = 429, + tVIPROGID = 430, + tVOID = 431, + tWCHAR = 432, + tWIREMARSHAL = 433, + tAPARTMENT = 434, + tNEUTRAL = 435, + tSINGLE = 436, + tFREE = 437, + tBOTH = 438, + CAST = 439, + PPTR = 440, + POS = 441, + NEG = 442, + ADDRESSOF = 443 }; #endif @@ -435,14 +443,13 @@ extern int parser_debug; typedef union YYSTYPE YYSTYPE; union YYSTYPE { -#line 138 "parser.y" /* yacc.c:355 */ +#line 144 "parser.y" /* yacc.c:355 */ attr_t *attr; attr_list_t *attr_list; str_list_t *str_list; expr_t *expr; expr_list_t *expr_list; - array_dims_t *array_dims; type_t *type; var_t *var; var_list_t *var_list; @@ -464,7 +471,7 @@ union YYSTYPE struct _decl_spec_t *declspec; enum storage_class stgclass; -#line 468 "parser.tab.c" /* yacc.c:355 */ +#line 475 "parser.tab.c" /* yacc.c:355 */ }; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -475,11 +482,11 @@ extern YYSTYPE parser_lval; int parser_parse (void); -#endif /* !YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ +#endif /* !YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ /* Copy the second part of user declarations. */ -#line 483 "parser.tab.c" /* yacc.c:358 */ +#line 490 "parser.tab.c" /* yacc.c:358 */ #ifdef short # undef short @@ -702,21 +709,21 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 2995 +#define YYLAST 3047 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 211 +#define YYNTOKENS 213 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 105 +#define YYNNTS 113 /* YYNRULES -- Number of rules. */ -#define YYNRULES 394 +#define YYNRULES 410 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 691 +#define YYNSTATES 718 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 441 +#define YYMAXUTOK 443 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -728,16 +735,16 @@ static const yytype_uint8 yytranslate[] = 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 195, 2, 2, 2, 194, 187, 2, - 208, 209, 192, 191, 182, 190, 202, 193, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 184, 207, - 188, 210, 189, 183, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 197, 2, 2, 2, 196, 189, 2, + 210, 211, 194, 193, 184, 192, 204, 195, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 186, 209, + 190, 212, 191, 185, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 203, 2, 204, 186, 2, 2, 2, 2, 2, + 2, 205, 2, 206, 188, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 205, 185, 206, 196, 2, 2, 2, + 2, 2, 2, 207, 187, 208, 198, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -768,54 +775,56 @@ static const yytype_uint8 yytranslate[] = 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 197, 198, 199, - 200, 201 + 175, 176, 177, 178, 179, 180, 181, 182, 183, 199, + 200, 201, 202, 203 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 321, 321, 335, 336, 336, 338, 339, 340, 343, - 346, 347, 348, 351, 352, 353, 353, 355, 356, 357, - 360, 361, 362, 363, 366, 367, 370, 371, 375, 376, - 377, 378, 379, 380, 381, 384, 395, 396, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 411, 413, 421, - 427, 431, 432, 434, 438, 445, 446, 449, 450, 453, - 454, 458, 463, 470, 474, 475, 478, 479, 483, 486, - 487, 488, 491, 492, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, - 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, - 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, - 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, - 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, - 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, - 594, 595, 596, 597, 601, 602, 607, 608, 609, 610, - 613, 614, 617, 621, 627, 628, 629, 632, 636, 648, - 652, 657, 660, 661, 664, 665, 668, 669, 670, 671, - 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, - 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, - 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, - 702, 703, 704, 705, 707, 709, 710, 713, 714, 717, - 723, 729, 730, 733, 738, 745, 746, 749, 750, 754, - 755, 758, 762, 768, 776, 780, 785, 786, 789, 790, - 791, 794, 796, 799, 800, 801, 802, 803, 804, 805, - 806, 807, 808, 809, 812, 813, 816, 817, 818, 819, - 820, 821, 822, 823, 826, 827, 835, 841, 845, 848, - 849, 853, 856, 857, 860, 869, 870, 873, 874, 877, - 883, 889, 890, 893, 894, 897, 907, 916, 922, 926, - 927, 930, 931, 934, 939, 946, 947, 948, 952, 956, - 959, 960, 963, 964, 968, 969, 973, 974, 975, 979, - 981, 983, 987, 988, 989, 990, 998, 1000, 1002, 1007, - 1009, 1014, 1015, 1020, 1021, 1022, 1023, 1028, 1037, 1039, - 1040, 1045, 1047, 1051, 1052, 1059, 1060, 1061, 1062, 1063, - 1068, 1076, 1077, 1080, 1081, 1084, 1091, 1092, 1097, 1098, - 1102, 1103, 1104, 1105, 1106, 1110, 1111, 1112, 1115, 1118, - 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1130, - 1137, 1139, 1145, 1146, 1147 + 0, 327, 327, 344, 344, 346, 347, 347, 349, 350, + 351, 354, 357, 358, 359, 362, 363, 364, 364, 366, + 367, 368, 371, 372, 373, 374, 377, 378, 381, 382, + 386, 387, 388, 389, 390, 391, 392, 395, 406, 407, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 422, + 424, 432, 438, 446, 447, 449, 457, 468, 469, 472, + 473, 476, 477, 481, 486, 493, 497, 498, 501, 502, + 506, 509, 510, 511, 514, 515, 518, 519, 520, 521, + 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, + 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, + 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, + 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, + 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, + 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, + 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, + 592, 593, 597, 598, 599, 600, 601, 602, 603, 604, + 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, + 615, 616, 617, 618, 619, 620, 624, 625, 630, 631, + 632, 633, 636, 637, 640, 644, 650, 651, 652, 655, + 659, 671, 675, 680, 683, 684, 687, 688, 691, 692, + 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, + 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, + 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, + 723, 724, 725, 726, 727, 728, 730, 732, 733, 736, + 737, 740, 746, 752, 753, 756, 761, 768, 769, 772, + 773, 777, 778, 781, 785, 791, 799, 803, 808, 809, + 812, 813, 814, 817, 819, 822, 823, 824, 825, 826, + 827, 828, 829, 830, 831, 832, 835, 836, 839, 840, + 841, 842, 843, 844, 845, 846, 847, 850, 851, 859, + 865, 869, 872, 873, 877, 880, 881, 884, 893, 894, + 897, 898, 901, 907, 913, 914, 917, 918, 921, 931, + 941, 947, 951, 952, 955, 956, 959, 964, 971, 972, + 973, 977, 981, 984, 985, 988, 989, 993, 994, 998, + 999, 1000, 1004, 1006, 1008, 1012, 1013, 1014, 1015, 1023, + 1025, 1027, 1032, 1034, 1039, 1040, 1045, 1046, 1047, 1048, + 1053, 1062, 1064, 1065, 1070, 1072, 1076, 1077, 1084, 1085, + 1086, 1087, 1088, 1093, 1101, 1102, 1105, 1106, 1109, 1116, + 1117, 1122, 1123, 1127, 1128, 1129, 1130, 1131, 1135, 1136, + 1137, 1140, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, + 1151, 1152, 1155, 1162, 1164, 1170, 1171, 1172, 1175, 1177, + 1179, 1181, 1184, 1189, 1197, 1198, 1201, 1202, 1205, 1206, + 1207 }; #endif @@ -826,26 +835,27 @@ static const char *const yytname[] = { "$end", "error", "$undefined", "aIDENTIFIER", "aPRAGMA", "aKNOWNTYPE", "aNUM", "aHEXNUM", "aDOUBLE", "aSTRING", "aWSTRING", "aSQSTRING", - "aUUID", "aEOF", "SHL", "SHR", "MEMBERPTR", "EQUALITY", "INEQUALITY", - "GREATEREQUAL", "LESSEQUAL", "LOGICALOR", "LOGICALAND", "ELLIPSIS", - "tAGGREGATABLE", "tALLOCATE", "tANNOTATION", "tAPPOBJECT", "tASYNC", - "tASYNCUUID", "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN", "tBROADCAST", - "tBYTE", "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE", "tCDECL", - "tCHAR", "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST", "tCONTEXTHANDLE", - "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE", "tCONTROL", - "tCPPQUOTE", "tDECODE", "tDEFAULT", "tDEFAULTBIND", "tDEFAULTCOLLELEM", - "tDEFAULTVALUE", "tDEFAULTVTABLE", "tDISABLECONSISTENCYCHECK", - "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME", "tDOUBLE", "tDUAL", - "tENABLEALLOCATE", "tENCODE", "tENDPOINT", "tENTRY", "tENUM", - "tERRORSTATUST", "tEXPLICITHANDLE", "tEXTERN", "tFALSE", "tFASTCALL", - "tFAULTSTATUS", "tFLOAT", "tFORCEALLOCATE", "tHANDLE", "tHANDLET", - "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING", "tHELPSTRINGCONTEXT", - "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID", "tIDEMPOTENT", "tIGNORE", - "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE", "tIMPORT", "tIMPORTLIB", - "tIN", "tIN_LINE", "tINLINE", "tINPUTSYNC", "tINT", "tINT3264", "tINT64", - "tINTERFACE", "tLCID", "tLENGTHIS", "tLIBRARY", "tLICENSED", "tLOCAL", - "tLONG", "tMAYBE", "tMESSAGE", "tMETHODS", "tMODULE", "tNAMESPACE", - "tNOCODE", "tNONBROWSABLE", "tNONCREATABLE", "tNONEXTENSIBLE", "tNOTIFY", + "aUUID", "aEOF", "aACF", "SHL", "SHR", "MEMBERPTR", "EQUALITY", + "INEQUALITY", "GREATEREQUAL", "LESSEQUAL", "LOGICALOR", "LOGICALAND", + "ELLIPSIS", "tAGGREGATABLE", "tALLOCATE", "tANNOTATION", "tAPPOBJECT", + "tASYNC", "tASYNCUUID", "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN", + "tBROADCAST", "tBYTE", "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE", + "tCDECL", "tCHAR", "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST", + "tCONTEXTHANDLE", "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE", + "tCONTROL", "tCPPQUOTE", "tDECODE", "tDEFAULT", "tDEFAULTBIND", + "tDEFAULTCOLLELEM", "tDEFAULTVALUE", "tDEFAULTVTABLE", + "tDISABLECONSISTENCYCHECK", "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME", + "tDOUBLE", "tDUAL", "tENABLEALLOCATE", "tENCODE", "tENDPOINT", "tENTRY", + "tENUM", "tERRORSTATUST", "tEXPLICITHANDLE", "tEXTERN", "tFALSE", + "tFASTCALL", "tFAULTSTATUS", "tFLOAT", "tFORCEALLOCATE", "tHANDLE", + "tHANDLET", "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING", + "tHELPSTRINGCONTEXT", "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID", + "tIDEMPOTENT", "tIGNORE", "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE", + "tIMPORT", "tIMPORTLIB", "tIN", "tIN_LINE", "tINLINE", "tINPUTSYNC", + "tINT", "tINT32", "tINT3264", "tINT64", "tINTERFACE", "tLCID", + "tLENGTHIS", "tLIBRARY", "tLICENSED", "tLOCAL", "tLONG", "tMAYBE", + "tMESSAGE", "tMETHODS", "tMODULE", "tNAMESPACE", "tNOCODE", + "tNONBROWSABLE", "tNONCREATABLE", "tNONEXTENSIBLE", "tNOTIFY", "tNOTIFYFLAG", "tNULL", "tOBJECT", "tODL", "tOLEAUTOMATION", "tOPTIMIZE", "tOPTIONAL", "tOUT", "tPARTIALIGNORE", "tPASCAL", "tPOINTERDEFAULT", "tPRAGMA_WARNING", "tPROGID", "tPROPERTIES", "tPROPGET", "tPROPPUT", @@ -861,30 +871,32 @@ static const char *const yytname[] = "','", "'?'", "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "'-'", "'+'", "'*'", "'/'", "'%'", "'!'", "'~'", "CAST", "PPTR", "POS", "NEG", "ADDRESSOF", "'.'", "'['", "']'", "'{'", "'}'", "';'", "'('", "')'", - "'='", "$accept", "input", "gbl_statements", "$@1", "imp_statements", - "$@2", "int_statements", "semicolon_opt", "statement", "pragma_warning", - "warnings", "typedecl", "cppquote", "import_start", "import", - "importlib", "libraryhdr", "library_start", "librarydef", "m_args", - "arg_list", "args", "arg", "array", "m_attributes", "attributes", - "attrib_list", "str_list", "attribute", "uuid_string", "callconv", - "cases", "case", "enums", "enum_list", "enum", "enumdef", "m_exprs", - "m_expr", "expr", "expr_list_int_const", "expr_int_const", "expr_const", - "fields", "field", "ne_union_field", "ne_union_fields", "union_field", - "s_field", "funcdef", "declaration", "m_ident", "t_ident", "ident", - "base_type", "m_int", "int_std", "coclass", "coclasshdr", "coclassdef", - "namespacedef", "coclass_ints", "coclass_int", "dispinterface", - "dispinterfacehdr", "dispint_props", "dispint_meths", "dispinterfacedef", - "inherit", "interface", "interfacehdr", "interfacedef", "interfacedec", - "module", "modulehdr", "moduledef", "storage_cls_spec", - "function_specifier", "type_qualifier", "m_type_qual_list", "decl_spec", - "m_decl_spec_no_type", "decl_spec_no_type", "declarator", - "direct_declarator", "abstract_declarator", - "abstract_declarator_no_direct", "m_abstract_declarator", - "abstract_direct_declarator", "any_declarator", + "'='", "$accept", "input", "m_acf", "gbl_statements", "$@1", + "imp_statements", "$@2", "int_statements", "semicolon_opt", "statement", + "pragma_warning", "warnings", "typedecl", "cppquote", "import_start", + "import", "importlib", "libraryhdr", "library_start", "librarydef", + "m_args", "arg_list", "args", "arg", "array", "m_attributes", + "attributes", "attrib_list", "str_list", "attribute", "uuid_string", + "callconv", "cases", "case", "enums", "enum_list", "enum", "enumdef", + "m_exprs", "m_expr", "expr", "expr_list_int_const", "expr_int_const", + "expr_const", "fields", "field", "ne_union_field", "ne_union_fields", + "union_field", "s_field", "funcdef", "declaration", "m_ident", "t_ident", + "ident", "base_type", "m_int", "int_std", "coclass", "coclasshdr", + "coclassdef", "namespacedef", "coclass_ints", "coclass_int", + "dispinterface", "dispinterfacehdr", "dispint_props", "dispint_meths", + "dispinterfacedef", "inherit", "interface", "interfacehdr", + "interfacedef", "interfacedec", "module", "modulehdr", "moduledef", + "storage_cls_spec", "function_specifier", "type_qualifier", + "m_type_qual_list", "decl_spec", "m_decl_spec_no_type", + "decl_spec_no_type", "declarator", "direct_declarator", + "abstract_declarator", "abstract_declarator_no_direct", + "m_abstract_declarator", "abstract_direct_declarator", "any_declarator", "any_declarator_no_direct", "m_any_declarator", "any_direct_declarator", "declarator_list", "m_bitfield", "struct_declarator", "struct_declarator_list", "init_declarator", "threading_type", - "pointer_type", "structdef", "type", "typedef", "uniondef", "version", YY_NULL + "pointer_type", "structdef", "type", "typedef", "uniondef", "version", + "acf_statements", "acf_int_statements", "acf_int_statement", + "acf_interface", "acf_attributes", "acf_attribute_list", "acf_attribute", YY_NULL }; #endif @@ -911,19 +923,19 @@ static const yytype_uint16 yytoknum[] = 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, - 435, 436, 44, 63, 58, 124, 94, 38, 60, 62, - 45, 43, 42, 47, 37, 33, 126, 437, 438, 439, - 440, 441, 46, 91, 93, 123, 125, 59, 40, 41, - 61 + 435, 436, 437, 438, 44, 63, 58, 124, 94, 38, + 60, 62, 45, 43, 42, 47, 37, 33, 126, 439, + 440, 441, 442, 443, 46, 91, 93, 123, 125, 59, + 40, 41, 61 }; # endif -#define YYPACT_NINF -521 +#define YYPACT_NINF -560 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-521))) + (!!((Yystate) == (-560))) -#define YYTABLE_NINF -260 +#define YYTABLE_NINF -405 #define yytable_value_is_error(Yytable_value) \ 0 @@ -932,76 +944,78 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - -521, 89, 1646, -521, -521, -521, -521, -521, -521, 156, - -521, -136, 172, -521, 181, -521, -521, -521, -521, -6, - 87, -521, -521, -521, -521, 218, -6, 105, -99, -521, - -75, -6, 384, -521, -521, 223, 255, 384, -521, -521, - 2819, -521, -521, -39, -521, -521, -521, -521, -521, 25, - 2519, -19, -15, -521, -521, -11, 6, -521, 24, 3, - 27, 15, 29, 21, -521, -521, 66, -521, 44, 44, - 44, 162, 2667, 79, 44, 106, 109, -521, -521, 208, - -521, -521, 94, -521, 74, -521, -521, 119, -521, -521, - -521, -521, 279, 2667, -521, -521, 97, 107, -127, -120, - -521, -521, 122, -521, -521, 125, -521, -521, -521, 126, - 131, -521, -521, -521, -521, -521, -521, -521, -521, -521, - -521, 155, -521, -521, -521, 160, -521, -521, -521, 161, - 173, -521, -521, -521, -521, 179, 180, 183, 184, 192, - -521, 193, -521, -521, 195, -521, 196, -521, -521, 197, - 205, -521, -521, -521, -521, -521, -521, -521, -521, -521, - -521, -521, -521, -521, 211, -521, -521, -521, 212, 213, - -521, -521, -521, -521, -521, -521, 214, -521, -521, 215, - -521, -521, -521, 217, -521, -521, -521, 222, 246, 247, - 251, -521, -521, -521, 252, 260, -521, -521, 261, 263, - 264, -121, -521, -521, -521, 1528, 791, 177, 319, 322, - 337, 343, 347, 207, 182, -521, -521, -521, -521, 162, - 209, 268, -521, -521, -521, -521, -521, -55, -521, -521, - -521, 350, 271, -521, -521, -521, -521, -521, -521, -521, - -521, -521, -521, -521, -521, 162, 162, -521, 267, -96, - -521, -521, -521, 44, -521, -521, -521, 269, 355, -521, - 289, 270, -521, 276, -521, 477, 61, 355, 646, 646, - 478, 479, 646, 646, 482, 491, 646, 493, 646, 646, - 2080, 646, 646, 494, -78, 497, 646, 2667, 646, 646, - 2667, 194, 2667, 2667, 61, 75, 501, 2667, 2819, 308, - -521, 309, -521, -521, -521, 311, -521, 314, -521, -521, - -521, 15, 2593, -521, 326, -521, -521, -521, -521, 326, - -102, -521, -521, -37, -521, 332, -66, 320, 329, -521, - -521, 1130, 72, 327, -521, 646, 266, 2080, -521, -521, - -521, 333, 353, -521, 328, 534, -521, -30, 177, -21, - 335, -521, -521, 336, 341, -521, -521, -521, -521, -521, - -521, -521, -521, -521, 339, -521, 646, 646, 646, 646, - 646, 646, 575, 2328, -143, -521, 2328, 342, 344, -521, - -123, 346, 348, 349, 351, 352, 354, 357, 1334, 358, - 2593, 159, 359, -118, -521, 2328, 362, 363, 364, 367, - 365, -114, 2001, 368, -521, -521, -521, -521, -521, 370, - 378, 379, 380, 374, -521, 381, 382, 383, -521, 2819, - 543, -521, -521, -521, 162, 15, -23, -521, 1027, -521, - 375, 2593, 387, 1410, 389, 474, 1233, 15, -521, 2593, - -521, -521, -521, -521, 594, -521, 2242, 390, 414, -521, - -521, -521, 355, 646, -521, 18, -521, 2593, -521, 397, - -521, 391, -521, 401, -521, -521, -521, 2593, 12, 12, - 12, 12, 12, 12, 2111, 338, 646, 646, 607, 646, - 646, 646, 646, 646, 646, 646, 646, 646, 646, 646, - 646, 646, 646, 646, 646, 646, 608, 646, 646, -521, - -521, -521, 604, -521, -521, -521, -521, -521, -521, -521, - -521, -521, -521, 159, -521, 1775, -521, 159, -521, -521, - -521, -93, -521, 646, -521, -521, -521, -521, 646, -521, - -521, -521, -521, -521, -521, -521, -521, 610, -521, -521, - -521, -521, 405, -521, -521, 435, -521, -521, -521, -521, - 162, 169, -521, -521, 2593, 413, -521, -521, -521, 15, - -521, -521, -521, -521, 2006, -521, -521, -521, -521, 159, - 419, 355, -521, -521, 338, -521, -521, 1903, -521, 338, - -521, 420, -58, 204, 204, -521, 718, 718, 305, 305, - 2198, 2347, 2307, 103, 506, 2354, 305, 305, 115, 115, - 12, 12, 12, -521, 2270, -521, -521, -521, 340, -521, - 421, 159, 423, -521, 2080, -521, -521, 425, -521, 15, - 909, 162, -521, -521, 1336, -521, -521, -521, 444, -521, - -115, -521, 431, -521, 429, 498, -521, 430, 159, 434, - -521, 646, 2080, -521, 646, -521, -521, 340, -521, -521, - -521, 437, -521, -521, -521, -521, 15, 646, -521, 159, - -521, -521, -521, -521, 340, -521, -521, -521, 12, 438, - 2328, -521, -521, -521, -521, -521, -13, -521, -521, 646, - 475, -521, -521, 476, -52, -52, -521, -521, 454, -521, - -521 + -560, 94, 1606, -560, -560, -560, -57, -560, -560, -560, + 147, -560, -89, 165, -560, 169, -560, -560, -560, -560, + 35, 149, -560, -560, -560, -560, -560, 172, 35, 164, + -34, -560, -29, 35, 333, -560, -560, 192, 197, 333, + -560, -560, 2869, -560, -560, -560, -27, -560, -560, -560, + -560, -560, 21, 2567, -13, -10, -560, -560, 9, -36, + -560, 2, 12, 38, 23, 46, 41, -560, -560, 57, + -560, 128, 128, 128, 175, 2716, 76, 128, 81, 88, + 61, -560, -57, 219, -560, -560, 315, -560, -560, 15, + -560, 121, -560, -560, 123, -560, -560, -560, -560, 331, + 2716, -560, -560, 58, 129, -94, -112, -560, -560, 130, + -560, -560, 131, -560, -560, -560, 132, 134, -560, -560, + -560, -560, -560, -560, -560, -560, -560, -560, 138, -560, + -560, -560, 140, -560, -560, -560, 141, 146, -560, -560, + -560, -560, 150, 151, 153, 157, 158, -560, 160, -560, + -560, 161, -560, 163, -560, -560, 166, 167, -560, -560, + -560, -560, -560, -560, -560, -560, -560, -560, -560, -560, + -560, 168, -560, -560, -560, 170, 171, -560, -560, -560, + -560, -560, -560, 174, -560, -560, 185, -560, -560, -560, + 187, -560, -560, -560, 188, 189, 190, 191, -560, -560, + -560, 195, 196, -560, -560, 206, 209, 211, -132, -560, + -560, -560, 1736, 851, 133, 267, 270, 273, 283, 286, + 220, 148, -560, -560, -560, -560, 175, 173, 216, -560, + -560, -560, -560, -560, -42, -560, -560, -560, 290, 222, + -560, -560, -560, -560, -560, -560, -560, -560, -560, -560, + -560, -560, 175, 175, -560, 127, -101, -560, -560, -560, + 128, -560, -560, -560, -560, -560, -560, -119, -560, -560, + 374, 215, 291, -560, 249, 225, -560, 227, -560, 429, + 84, 291, 710, 710, 430, 432, 710, 710, 435, 458, + 710, 461, 710, 710, 2097, 710, 710, 463, -68, 464, + 710, 2716, 710, 710, 2716, -38, 2716, 2716, 84, 324, + 466, 2716, 2869, 271, -560, 268, -560, -560, -560, 272, + -560, 278, -560, -560, -560, 23, 2612, -560, 279, -560, + -560, -560, -560, 279, -91, -560, -560, -122, -560, 293, + -65, 280, 284, -560, -560, 1193, 52, 266, -560, 710, + 542, 2097, -560, -560, 61, -560, 285, -560, 282, 303, + -560, 281, 488, -560, -49, 133, -39, 294, -560, -560, + 295, 296, -560, -560, -560, -560, -560, -560, -560, -560, + -560, 305, -560, 710, 710, 710, 710, 710, 710, 596, + 2299, -135, -560, 2299, 306, 307, -560, -111, 308, 309, + 314, 316, 317, 323, 326, 371, 327, 2612, 77, 328, + -106, -560, 2299, 329, 330, 332, 311, 335, -100, 1397, + 343, -560, -560, -560, -560, -560, 344, 346, 359, 360, + 292, -560, 361, 362, 367, -560, 2869, 492, -560, -560, + -560, 175, 23, -11, -560, 1089, -560, 340, 2612, 370, + 1476, 334, 413, 1297, 23, -560, 2612, -560, -560, -560, + -560, 611, -560, 2190, 377, 402, -560, -560, -560, 380, + -560, 291, 710, -560, 18, -560, 2612, -560, 378, -560, + 384, -560, 389, -560, -560, -560, 2612, 36, 36, 36, + 36, 36, 36, 2102, 496, 710, 710, 597, 710, 710, + 710, 710, 710, 710, 710, 710, 710, 710, 710, 710, + 710, 710, 710, 710, 710, 605, 710, 710, -560, -560, + -560, 600, -560, -560, -560, -560, -560, -560, -560, -560, + -560, -560, 77, -560, 1833, -560, 77, -560, -560, -560, + -87, -560, 710, -560, -560, -560, -560, 710, -560, -560, + -560, -560, -560, -560, -560, -560, 604, -560, -560, -560, + -560, 400, -560, -560, 428, -560, -560, -560, -560, 175, + 116, -560, -560, 2612, 407, -560, -560, -560, 23, -560, + -560, -560, -560, 2009, 419, 417, 380, -560, -560, -560, + -560, 77, 418, 291, -560, -560, 496, -560, -560, 1921, + -560, 496, -560, 415, -74, 318, 318, -560, 575, 575, + 482, 482, 2318, 2337, 2260, 2372, 2394, 218, 482, 482, + 54, 54, 36, 36, 36, -560, 2212, -560, -560, -560, + 74, -560, 421, 77, 422, -560, 2097, -560, -560, 424, + -560, 23, 970, 175, -560, -560, 1401, -560, -560, -560, + 623, -560, -560, 444, -560, -103, -560, 431, -560, 425, + 375, -560, 434, 77, 437, -560, 710, 2097, -560, 710, + -560, -560, 74, -560, -560, -560, 440, -560, -560, -560, + -560, 23, 433, 710, -560, 77, -560, -560, -560, -560, + 74, -560, -560, -560, 36, 441, 2299, -560, -560, -560, + -560, -560, -560, -1, -560, -560, 710, 453, -560, -560, + 468, -58, -58, -560, -560, 447, -560, -560 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1009,108 +1023,112 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 3, 0, 2, 1, 33, 380, 271, 263, 282, 0, - 319, 0, 0, 270, 258, 272, 315, 269, 273, 274, - 0, 318, 276, 283, 281, 0, 274, 0, 0, 317, - 0, 274, 0, 278, 316, 258, 258, 268, 379, 264, - 74, 12, 34, 0, 28, 13, 31, 13, 11, 0, - 67, 382, 0, 381, 265, 0, 0, 9, 0, 0, - 0, 26, 0, 301, 7, 6, 0, 10, 324, 324, - 324, 0, 0, 384, 324, 0, 386, 284, 285, 0, - 292, 293, 383, 260, 0, 275, 280, 0, 303, 304, - 279, 288, 0, 0, 277, 266, 385, 0, 387, 0, - 267, 75, 0, 77, 78, 0, 79, 80, 81, 0, - 0, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 0, 95, 96, 97, 0, 99, 100, 101, 0, - 0, 104, 105, 106, 107, 0, 0, 0, 0, 0, - 113, 0, 115, 116, 0, 118, 0, 120, 121, 124, - 0, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 0, 139, 140, 141, 0, 0, - 144, 145, 146, 147, 377, 148, 0, 150, 375, 0, - 152, 153, 154, 0, 156, 157, 158, 0, 0, 0, - 0, 163, 376, 164, 0, 0, 168, 169, 0, 0, - 0, 0, 69, 173, 29, 66, 66, 66, 258, 0, - 0, 258, 258, 0, 382, 286, 294, 305, 313, 0, - 384, 386, 30, 8, 289, 4, 310, 0, 27, 308, - 309, 0, 0, 24, 328, 325, 327, 326, 261, 262, - 176, 177, 178, 179, 320, 0, 0, 332, 368, 331, - 255, 382, 384, 324, 386, 322, 32, 0, 184, 48, - 0, 0, 241, 0, 247, 0, 0, 0, 0, 0, + 5, 0, 3, 1, 35, 383, 398, 273, 265, 284, + 0, 322, 0, 0, 272, 260, 274, 318, 271, 275, + 276, 0, 321, 278, 285, 286, 283, 0, 276, 0, + 0, 320, 0, 276, 0, 280, 319, 260, 260, 270, + 382, 266, 76, 2, 14, 36, 0, 30, 15, 33, + 15, 13, 0, 69, 385, 0, 384, 267, 0, 0, + 11, 0, 0, 0, 28, 0, 304, 9, 8, 0, + 12, 327, 327, 327, 0, 0, 387, 327, 0, 389, + 0, 4, 398, 0, 287, 288, 0, 295, 296, 386, + 262, 0, 277, 282, 0, 306, 307, 281, 291, 0, + 0, 279, 268, 388, 0, 390, 0, 269, 77, 0, + 79, 80, 0, 81, 82, 83, 0, 0, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 0, 97, + 98, 99, 0, 101, 102, 103, 0, 0, 106, 107, + 108, 109, 0, 0, 0, 0, 0, 115, 0, 117, + 118, 0, 120, 0, 122, 123, 126, 0, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 0, 141, 142, 143, 0, 0, 146, 147, 148, + 149, 380, 150, 0, 152, 378, 0, 154, 155, 156, + 0, 158, 159, 160, 0, 0, 0, 0, 165, 379, + 166, 0, 0, 170, 171, 0, 0, 0, 0, 71, + 175, 31, 68, 68, 68, 260, 0, 0, 260, 260, + 0, 385, 289, 297, 308, 316, 0, 387, 389, 32, + 10, 292, 6, 313, 0, 29, 311, 312, 0, 0, + 26, 331, 328, 330, 329, 263, 264, 178, 179, 180, + 181, 323, 0, 0, 335, 371, 334, 257, 385, 387, + 327, 389, 325, 34, 409, 408, 410, 0, 406, 399, + 0, 0, 186, 50, 0, 0, 243, 0, 249, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 194, 0, 0, 0, 0, 0, 194, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 74, 68, - 49, 0, 21, 22, 23, 0, 19, 0, 17, 14, - 20, 26, 0, 67, 383, 51, 52, 311, 312, 385, - 387, 53, 254, 66, 3, 0, 66, 0, 0, 302, - 24, 66, 0, 0, 330, 0, 0, 55, 334, 323, - 47, 0, 186, 187, 190, 0, 388, 66, 66, 66, - 0, 175, 174, 0, 0, 205, 196, 197, 198, 202, - 203, 204, 199, 200, 0, 201, 0, 0, 0, 0, - 0, 0, 0, 239, 0, 237, 240, 0, 0, 72, + 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, + 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 76, 70, 51, 0, 23, 24, 25, 0, + 21, 0, 19, 16, 22, 28, 0, 69, 386, 53, + 54, 314, 315, 388, 390, 55, 256, 68, 5, 0, + 68, 0, 0, 305, 26, 68, 0, 0, 333, 0, + 0, 57, 337, 326, 0, 405, 0, 49, 0, 188, + 189, 192, 0, 391, 68, 68, 68, 0, 177, 176, + 0, 0, 207, 198, 199, 200, 204, 205, 206, 201, + 202, 0, 203, 0, 0, 0, 0, 0, 0, 0, + 241, 0, 239, 242, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 356, 0, + 0, 194, 197, 0, 0, 0, 0, 0, 0, 0, + 0, 373, 374, 375, 376, 377, 0, 0, 0, 0, + 395, 397, 0, 0, 0, 72, 76, 0, 20, 17, + 56, 0, 28, 0, 293, 68, 298, 0, 0, 0, + 0, 0, 0, 68, 28, 27, 69, 324, 332, 336, + 372, 0, 67, 0, 0, 61, 58, 59, 407, 400, + 193, 187, 0, 38, 0, 381, 0, 244, 0, 393, + 69, 250, 0, 78, 169, 84, 0, 231, 230, 229, + 232, 227, 228, 0, 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 353, 0, 0, 192, 195, 0, 0, 0, 0, - 0, 0, 0, 0, 370, 371, 372, 373, 374, 0, - 0, 0, 0, 392, 394, 0, 0, 0, 70, 74, - 0, 18, 15, 54, 0, 26, 0, 290, 66, 295, - 0, 0, 0, 0, 0, 0, 66, 26, 25, 67, - 321, 329, 333, 369, 0, 65, 0, 0, 59, 56, - 57, 191, 185, 0, 36, 0, 378, 0, 242, 0, - 390, 67, 248, 0, 76, 167, 82, 0, 229, 228, - 227, 230, 225, 226, 0, 341, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, - 94, 98, 0, 102, 103, 108, 109, 110, 111, 112, - 114, 117, 119, 353, 320, 55, 358, 353, 355, 354, - 62, 350, 123, 194, 122, 138, 142, 143, 0, 151, - 155, 159, 160, 162, 161, 165, 166, 0, 170, 171, - 172, 71, 0, 13, 361, 389, 287, 291, 5, 297, - 0, 384, 296, 299, 0, 0, 253, 300, 24, 26, - 314, 64, 63, 335, 0, 188, 189, 37, 35, 0, - 386, 256, 246, 245, 341, 236, 320, 55, 345, 341, - 342, 0, 338, 218, 219, 231, 212, 213, 216, 217, - 207, 208, 0, 209, 210, 211, 215, 214, 221, 220, - 223, 224, 222, 232, 0, 238, 73, 61, 353, 320, - 0, 353, 0, 349, 55, 357, 193, 0, 393, 26, - 66, 0, 251, 298, 66, 306, 60, 58, 363, 366, - 0, 244, 0, 257, 0, 341, 320, 0, 353, 0, - 337, 0, 55, 344, 0, 235, 348, 353, 359, 352, - 356, 0, 149, 50, 16, 362, 26, 0, 365, 0, - 243, 180, 234, 336, 353, 346, 340, 343, 233, 0, - 206, 351, 360, 307, 364, 367, 0, 339, 347, 0, - 0, 391, 181, 0, 66, 66, 250, 183, 0, 182, - 249 + 0, 0, 0, 0, 0, 0, 0, 0, 85, 96, + 100, 0, 104, 105, 110, 111, 112, 113, 114, 116, + 119, 121, 356, 323, 57, 361, 356, 358, 357, 64, + 353, 125, 196, 124, 140, 144, 145, 0, 153, 157, + 161, 162, 164, 163, 167, 168, 0, 172, 173, 174, + 73, 0, 15, 364, 392, 290, 294, 7, 300, 0, + 387, 299, 302, 0, 0, 255, 303, 26, 28, 317, + 66, 65, 338, 0, 404, 0, 400, 190, 191, 39, + 37, 0, 389, 258, 248, 247, 344, 238, 323, 57, + 348, 344, 345, 0, 341, 220, 221, 233, 214, 215, + 218, 219, 209, 210, 0, 211, 212, 213, 217, 216, + 223, 222, 225, 226, 224, 234, 0, 240, 75, 63, + 356, 323, 0, 356, 0, 352, 57, 360, 195, 0, + 396, 28, 68, 0, 253, 301, 68, 309, 62, 60, + 0, 403, 401, 366, 369, 0, 246, 0, 259, 0, + 344, 323, 0, 356, 0, 340, 0, 57, 347, 0, + 237, 351, 356, 362, 355, 359, 0, 151, 52, 18, + 365, 28, 0, 0, 368, 0, 245, 182, 236, 339, + 356, 349, 343, 346, 235, 0, 208, 354, 363, 310, + 402, 367, 370, 0, 342, 350, 0, 0, 394, 183, + 0, 68, 68, 252, 185, 0, 184, 251 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -521, -521, 360, -521, -42, -521, -304, -291, 0, -521, - -521, -521, -521, -521, 227, -521, -521, -521, 10, -472, - -521, -521, -266, -218, -191, -2, -521, -521, -275, 369, - -65, -521, -521, -521, -521, 216, 13, 377, 143, -242, - -521, -228, -264, -521, -521, -521, -521, -18, -177, -521, - 237, -521, -3, -67, -521, 110, 116, 5, -521, 11, - 17, -521, -521, 624, -521, -521, -521, -521, -521, -33, - -521, 19, 16, -521, -521, 20, -521, -521, -298, -462, - -49, 32, 30, -235, -521, -521, -521, -495, -521, -520, - -521, -448, -521, -521, -521, 22, -521, 456, -521, 392, - 1, -31, -521, 7, -521 + -560, -560, -560, 320, -560, -46, -560, -317, -315, 0, + -560, -560, -560, -560, -560, 208, -560, -560, -560, 10, + -514, -560, -560, -261, -242, -203, -2, -560, -560, -272, + 354, -66, -560, -560, -560, -560, 198, 13, 366, 137, + -195, -560, -264, -280, -560, -560, -560, -560, -41, -237, + -560, 233, -560, 25, -69, -560, 42, 99, 5, -560, + 11, 17, -560, -560, 619, -560, -560, -560, -560, -560, + -18, -560, 19, 16, -560, -560, 20, -560, -560, -307, + -496, -52, -43, -30, -236, -560, -560, -560, -540, -560, + -559, -560, 51, -560, -560, -560, 3, -560, 459, -560, + 391, 1, -50, -560, 7, -560, 615, 112, -560, -560, + 115, -560, 348 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 2, 324, 205, 543, 331, 229, 302, 42, - 455, 43, 44, 45, 46, 303, 213, 47, 304, 447, - 448, 449, 450, 516, 49, 313, 201, 380, 202, 353, - 517, 676, 682, 341, 342, 343, 251, 393, 394, 373, - 374, 375, 377, 347, 458, 462, 349, 687, 688, 555, - 52, 632, 84, 518, 53, 86, 54, 305, 56, 306, - 307, 323, 427, 59, 60, 326, 433, 61, 232, 62, - 63, 308, 309, 218, 66, 310, 68, 69, 70, 332, - 71, 234, 72, 248, 249, 580, 639, 581, 582, 519, - 612, 520, 521, 545, 658, 629, 630, 250, 409, 203, - 252, 74, 75, 254, 415 + -1, 1, 43, 2, 338, 212, 562, 345, 236, 316, + 45, 474, 46, 47, 48, 49, 317, 220, 50, 318, + 464, 465, 466, 467, 535, 52, 327, 208, 397, 209, + 370, 536, 703, 709, 358, 359, 360, 258, 410, 411, + 390, 391, 392, 394, 364, 477, 481, 366, 714, 715, + 574, 55, 657, 91, 537, 56, 93, 57, 319, 59, + 320, 321, 337, 444, 62, 63, 340, 450, 64, 239, + 65, 66, 322, 323, 225, 69, 324, 71, 72, 73, + 346, 74, 241, 75, 255, 256, 602, 664, 603, 604, + 538, 634, 539, 540, 564, 684, 654, 655, 257, 426, + 210, 259, 77, 78, 261, 432, 81, 585, 586, 82, + 83, 267, 268 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1118,776 +1136,792 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 50, 219, 41, 73, 247, 206, 246, 55, 381, 76, - 333, 334, 48, 57, 389, 51, 312, 217, 65, 58, - 423, 64, 67, 418, 567, 679, 436, 376, 478, -259, - 376, 338, 97, 99, 440, 12, 263, 388, 680, 498, - 395, 253, 430, 610, 25, 382, 395, 402, 385, 628, - 387, 220, 608, 392, -259, 215, 174, 221, 399, 502, - 178, 298, 261, 214, 523, 607, 499, 659, 523, 613, - 351, 443, 79, 352, 325, 238, 25, 239, -259, 634, - -43, 413, 414, 299, 640, 264, 503, 192, 10, 3, - 85, 524, 660, 376, 446, 530, 87, 441, 235, 235, - 235, 236, 237, -259, 235, 637, 255, 336, 91, 92, - 336, 240, 337, 16, 635, 614, 10, 476, 477, 478, - 479, 480, 481, 482, 468, 469, 470, 471, 472, 473, - 474, 478, 426, 93, 546, 431, 90, 40, 21, 628, - 663, 94, 651, 241, 541, 336, 560, 647, 95, 432, - 642, 40, 247, 100, 246, 686, 457, 431, 431, 77, - 646, 78, 238, 649, 239, 238, 40, 239, 204, 425, - 669, 459, 463, 40, 664, 80, 456, 81, 247, 247, - 246, 246, 40, 29, 82, 460, 83, 207, -38, 544, - 666, 344, 222, 681, 327, 34, 223, 242, 240, 671, - 354, 240, 471, 50, 50, 231, 73, 73, 97, 99, - 226, 224, 76, 76, 496, 497, 677, 257, 51, 51, - 478, 88, 228, 89, 243, 566, 96, 568, 83, 225, - 241, 391, 227, 241, 583, 584, 230, 586, 587, 588, - 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, - 599, 600, 601, 602, 624, 604, 400, 578, 98, 403, - 83, 410, 411, 424, 244, 247, 417, 246, 625, 355, - 605, 233, 356, 357, 358, 359, 360, 361, 390, 258, - 245, 395, 260, 235, 242, 339, -40, 242, 391, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 627, -259, - 617, -39, -259, 615, -41, 496, 497, 493, 494, 495, - 440, 243, 262, 256, 243, 622, -42, 496, 497, 476, - 477, 478, 314, 475, 83, 315, 259, 316, 653, 439, - 265, 438, 73, 266, 267, 390, 362, 440, 76, 268, - 317, 513, 318, 238, 51, 239, 319, 461, 83, 440, - 320, 514, 83, 328, 244, 329, 578, 247, 238, 246, - 239, 578, 336, 269, 643, 673, 440, 515, 270, 271, - 245, 404, 405, 406, 407, 408, -252, 240, -252, 240, - 40, 272, 550, 363, 10, 344, 655, 273, 274, -44, - 219, 275, 276, 674, 491, 492, 493, 494, 495, 668, - 277, 278, 670, 279, 280, 281, 496, 497, 569, 241, - 579, 241, 321, 282, 364, 376, -45, 578, 574, 283, - 284, 285, 286, 287, 8, 288, 50, 365, 41, 73, - 289, 554, 551, 55, 439, 76, 438, 73, 48, 57, - 220, 51, 547, 76, 65, 58, 221, 64, 67, 51, - 611, 683, 214, 366, 290, 291, 367, 368, 444, 292, - 293, 370, 371, 242, 570, 242, 391, 19, 294, 295, - 445, 296, 297, 345, 372, -46, 330, 335, 340, 346, - 22, 23, 24, 247, 348, 246, 350, 378, 379, 26, - 243, 383, 243, 431, 431, 491, 492, 493, 494, 495, - 384, 620, 386, 396, 633, 219, 398, 496, 497, 579, - 416, 419, 638, 390, 579, 391, 429, 420, 421, 422, - 476, 477, 478, 479, 480, 481, 482, 434, 391, 31, - 576, -259, 514, 33, 435, 452, 442, 240, 453, 451, - 454, 336, 10, 336, 464, 465, 577, 467, 515, 528, - 466, 500, 542, 501, 247, 504, 246, 505, 506, 549, - 507, 508, 390, 509, 20, 391, 510, 512, 522, 241, - 579, 525, 526, 527, 529, 390, 537, 532, 355, 533, - 5, 356, 357, 358, 359, 360, 361, 534, 535, 536, - 538, 539, 540, 391, 552, 557, 564, 355, 572, 563, - 356, 357, 358, 359, 360, 361, 571, 6, 573, 7, - 585, 603, 390, 606, 619, 8, 618, 621, 50, 10, - 623, 73, 439, 242, 438, 73, 631, 76, 657, 641, - 648, 76, 650, 51, 652, 13, 661, 51, 662, 665, - 390, 208, 15, 667, 16, 362, 672, 678, 17, 355, - 243, 18, 356, 357, 358, 359, 360, 361, 19, 684, - 685, 690, 558, 412, 362, 401, 616, 689, 565, 21, - 556, 22, 23, 24, 216, 322, 397, 0, 0, 0, - 26, 675, 0, 0, 428, 0, 0, 0, 0, 0, - 576, 0, 363, 488, 489, 490, 491, 492, 493, 494, - 495, 336, 0, 0, 0, 0, 577, 0, 496, 497, - 0, 363, 0, 0, 29, 0, 362, 0, 0, 30, - 31, 32, 0, 364, 33, 0, 34, 0, 0, 0, - 211, 0, 476, 477, 478, 0, 365, 481, 482, 212, - 0, 37, 364, 0, 0, 0, 0, 0, 0, 38, - 39, 0, 0, 0, 0, 365, 0, 0, 0, 0, - 0, 0, 366, 363, 0, 367, 368, 369, 0, 0, - 370, 371, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 366, 0, 372, 367, 368, 369, 0, 0, 370, - 371, 0, 0, 0, 364, 4, 5, 0, 561, 0, - 0, 0, 372, 0, 0, 0, 0, 365, 0, 0, + 53, 226, 44, 76, 213, 254, 398, 58, 253, 79, + 440, 326, 51, 60, 352, 54, 347, 348, 68, 61, + 632, 67, 70, 399, 589, 260, 402, 453, 404, 243, + 244, 409, 653, 406, 262, 224, 416, 630, 706, 457, + 435, 242, 242, 242, -404, 447, 277, 242, 13, 517, + 275, 707, 312, 497, 227, 245, 659, 246, 222, 27, + 228, 665, 104, 106, -261, 354, 221, -261, 181, 460, + 97, 497, 185, 521, 313, 101, 518, 245, 542, 246, + 245, 685, 246, 42, 542, 662, 442, 355, 393, 339, + 27, 393, 247, 368, 3, 278, 369, 11, 405, 199, + 522, 412, 660, 449, 350, 543, 686, 412, 419, 351, + 458, 549, 264, -261, 247, -45, -261, 247, 350, 11, + 689, 86, 676, 636, 248, 265, 653, 565, 478, 482, + 266, 350, 92, 102, 443, 672, 667, 448, 107, 579, + 42, 421, 422, 423, 424, 425, 248, 42, 80, 248, + 84, 713, 85, 695, 393, 463, 42, 254, 94, 475, + 253, 476, 448, 448, 560, 690, 42, 98, 87, 479, + 88, 231, 89, 11, 90, 95, 99, 96, 245, 249, + 246, 100, 211, 254, 254, 214, 253, 253, 487, 488, + 489, 490, 491, 492, 493, 103, -40, 90, 17, 229, + 105, 249, 90, 361, 249, 563, 250, 708, 588, 232, + 53, 53, 371, 76, 76, 247, 341, 353, 230, 79, + 79, 233, -261, 22, -41, 54, 54, 238, 250, 590, + 242, 250, 235, 495, 496, 497, 498, 499, 500, 501, + 515, 516, 408, 104, 106, 234, 251, 248, 512, 513, + 514, 417, 600, 627, 420, 237, 427, 428, 515, 516, + 646, 434, 252, 647, 240, -261, 490, -43, 533, 31, + 328, 533, 90, 329, 441, 330, 331, 254, 332, 350, + 253, 36, 350, 639, 534, -42, 333, 534, 90, 334, + 263, 90, 407, 342, 245, 343, 246, -44, 637, 408, + 605, 606, 249, 608, 609, 610, 611, 612, 613, 614, + 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + 270, 626, 649, 457, 271, -254, 678, -254, 272, 250, + 430, 431, 273, 644, 274, 497, 276, 494, 42, 349, + 279, 280, 281, 456, 282, 455, 76, 412, 283, 407, + 284, 285, 79, 457, 600, 532, 286, -46, 54, 600, + 287, 288, 668, 289, 480, 457, 699, 290, 291, 251, + 292, 293, 254, 294, 9, 253, 295, 296, 297, 356, + 298, 299, -47, 457, 300, 252, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 301, 569, 302, 303, 304, + 305, 306, 361, 701, 226, 307, 308, 680, 508, 509, + 510, 511, 512, 513, 514, 247, 309, 20, 600, 310, + 11, 311, 515, 516, 591, -48, 357, 335, 601, 344, + 23, 24, 25, 26, 596, 362, 363, 365, 367, 395, + 28, 396, 710, 53, 400, 44, 76, 248, 573, 570, + 58, 456, 79, 455, 76, 51, 60, 227, 54, 566, + 79, 68, 61, 228, 67, 70, 54, 401, 633, 221, + 403, 694, 413, 415, 696, 433, 436, 459, 437, 446, + 33, 438, 408, 592, 35, 439, -261, 471, 393, 451, + 470, 452, 469, 472, 473, 547, 556, 495, 496, 497, + 254, 561, 249, 253, 21, 483, 484, 485, 448, 448, + 510, 511, 512, 513, 514, 486, 642, 519, 520, 523, + 524, 226, 515, 516, 658, 525, 568, 526, 527, 250, + 601, 408, 407, 663, 528, 601, 247, 529, 531, 541, + 544, 545, 576, 546, 584, 372, 548, 408, 373, 374, + 375, 376, 377, 378, 551, 552, 504, 553, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 248, 598, + 554, 555, 557, 558, 254, 515, 516, 253, 559, 571, + 350, 407, 530, 629, 408, 599, 583, 635, 582, 593, + 495, 496, 497, 594, 601, 500, 501, 407, 595, 372, + 607, 5, 373, 374, 375, 376, 377, 378, 625, 628, + 640, 641, 643, 379, 372, 408, 645, 373, 374, 375, + 376, 377, 378, 249, 80, 651, 666, 656, 682, 7, + 683, 8, 673, 675, 407, 677, 688, 9, 687, 711, + 53, 11, 700, 76, 456, 691, 455, 76, 693, 79, + 250, 698, 705, 79, 712, 54, 717, 14, 445, 54, + 577, 380, 429, 215, 16, 407, 17, 379, 418, 587, + 18, 716, 223, 19, 510, 511, 512, 513, 514, 638, + 20, 671, 379, 575, 674, 336, 515, 516, 702, 414, + 598, 22, 381, 23, 24, 25, 26, 269, 652, 650, + 0, 350, 468, 28, 0, 382, 599, 0, 0, 0, + 0, 0, 0, 372, 692, 380, 373, 374, 375, 376, + 377, 378, 0, 697, 0, 0, 0, 0, 0, 0, + 380, 383, 0, 0, 384, 385, 461, 31, 0, 387, + 388, 704, 32, 33, 34, 0, 381, 35, 462, 36, + 0, 0, 389, 218, 0, 0, 0, 0, 0, 382, + 0, 381, 219, 0, 39, 508, 509, 510, 511, 512, + 513, 514, 40, 41, 382, 0, 0, 0, 0, 515, + 516, 379, 0, 0, 0, 383, 0, 0, 384, 385, + 386, 0, 0, 387, 388, 0, 0, 0, 0, 0, + 383, 0, 0, 384, 385, 386, 389, 0, 387, 388, + 0, 0, 0, 0, 0, 0, 0, 580, 0, 0, + 0, 389, 0, 0, 0, 0, 0, 0, 0, 380, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 6, 0, 7, 0, 0, 0, 0, - 0, 8, 9, 366, 0, 10, 367, 368, 369, 0, - 11, 370, 371, 0, 0, 0, 0, 0, 0, 12, - 0, 13, 0, 0, 372, 0, 0, 14, 15, 0, - 16, 0, 0, 0, 17, 0, 0, 18, 0, 0, - 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, - 0, 20, 301, 0, 0, 21, 0, 22, 23, 24, - 25, 0, 0, 0, 0, 0, 26, 0, 0, 0, - 0, 27, 0, 0, 0, 0, 489, 490, 491, 492, - 493, 494, 495, 4, 5, 0, 0, 0, 28, 0, - 496, 497, 0, 0, 0, 0, 0, 0, 0, 0, - 29, 0, 0, 0, 0, 30, 31, 32, 0, 0, - 33, 6, 34, 7, 0, 0, 35, 0, 0, 8, - 9, 0, 0, 10, 0, 36, 0, 37, 11, 0, - 0, 0, 0, 0, 0, 38, 39, 12, 0, 13, - 0, 0, 0, 0, 0, 14, 15, 0, 16, 0, - 0, 0, 17, 0, 0, 18, 0, 0, 0, 0, - 0, 0, 19, 0, 40, 0, 0, 311, 0, 20, - 301, 0, 0, 21, 0, 22, 23, 24, 25, 0, - 0, 0, 0, 0, 26, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4, 5, 0, 0, 0, 28, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, - 0, 0, 0, 30, 31, 32, 0, 0, 33, 6, - 34, 7, 0, 0, 35, 0, 0, 8, 9, 0, - 0, 10, 0, 36, 0, 37, 11, 0, 0, 0, - 0, 0, 0, 38, 39, 12, 0, 13, 0, 0, - 0, 0, 0, 14, 15, 0, 16, 0, 0, 0, - 17, 0, 0, 18, 0, 0, 0, 0, 0, 0, - 19, 0, 40, 0, 0, 654, 0, 20, 0, 0, - 0, 21, 0, 22, 23, 24, 25, 0, 0, 0, - 0, 0, 26, 0, 4, 5, 0, 27, 0, 0, + 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, + 381, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 382, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 8, 0, 0, 0, + 0, 0, 9, 10, 0, 0, 11, 0, 0, 383, + 0, 12, 384, 385, 386, 0, 0, 387, 388, 0, + 13, 0, 14, 0, 0, 0, 0, 0, 15, 16, + 389, 17, 0, 0, 0, 18, 0, 0, 19, 0, + 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, + 0, 0, 21, 315, 0, 0, 22, 0, 23, 24, + 25, 26, 27, 0, 0, 0, 0, 0, 28, 0, + 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, + 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 31, 0, 0, 0, 0, 32, 33, 34, + 0, 0, 35, 7, 36, 8, 0, 0, 37, 0, + 0, 9, 10, 0, 0, 11, 0, 38, 0, 39, + 12, 0, 0, 0, 0, 0, 0, 40, 41, 13, + 0, 14, 0, 0, 0, 0, 0, 15, 16, 0, + 17, 0, 0, 0, 18, 0, 0, 19, 0, 0, + 0, 0, 0, 0, 20, 0, 42, 0, 0, 325, + 0, 21, 315, 0, 0, 22, 0, 23, 24, 25, + 26, 27, 0, 0, 0, 0, 0, 28, 0, 0, + 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, - 0, 0, 6, 0, 7, 0, 29, 0, 0, 0, - 8, 30, 31, 32, 10, 0, 33, 0, 34, 11, - 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, - 13, 36, 0, 37, 0, 0, 14, 15, 0, 16, - 0, 38, 39, 17, 0, 0, 18, 0, 0, 0, - 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, - 20, 0, 0, 0, 21, 0, 22, 23, 24, 0, - 40, 0, 0, 548, 0, 26, 0, 4, 5, 0, + 0, 31, 0, 0, 0, 0, 32, 33, 34, 0, + 0, 35, 7, 36, 8, 0, 0, 37, 0, 0, + 9, 10, 0, 0, 11, 0, 38, 0, 39, 12, + 0, 0, 0, 0, 0, 0, 40, 41, 13, 0, + 14, 0, 0, 0, 0, 0, 15, 16, 0, 17, + 0, 0, 0, 18, 0, 0, 19, 0, 0, 0, + 0, 0, 0, 20, 0, 42, 0, 0, 679, 0, + 21, 0, 0, 0, 22, 0, 23, 24, 25, 26, + 27, 0, 0, 0, 0, 0, 28, 4, 5, 0, + 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 8, 0, + 31, 0, 0, 0, 9, 32, 33, 34, 11, 0, + 35, 0, 36, 12, 0, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 14, 38, 0, 39, 0, 0, + 15, 16, 0, 17, 0, 40, 41, 18, 0, 0, + 19, 0, 0, 0, 0, 0, 0, 20, 0, 0, + 0, 0, 0, 0, 21, 0, 0, 0, 22, 0, + 23, 24, 25, 26, 42, 0, 0, 567, 0, 0, + 28, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, - 0, 0, 0, 0, 0, 6, 0, 7, 0, 29, - 0, 0, 0, 8, 30, 31, 32, 10, 0, 33, - 0, 34, 11, 0, 0, 35, 0, 0, 0, 0, - 0, 0, 0, 13, 36, 0, 37, 0, 0, 14, - 15, 0, 16, 0, 38, 39, 17, 0, 0, 18, - 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, - 0, 0, 0, 20, 0, 0, 0, 21, 0, 22, - 23, 24, 0, 40, 0, 0, 437, 0, 26, 0, - 4, 5, 0, 0, 0, 0, 0, 0, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 0, 0, 0, - 28, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 7, 0, 29, 0, 0, 0, 8, 30, 31, 32, - 10, 0, 33, 0, 34, 11, 0, 0, 35, 0, - 0, 0, 0, 0, 0, 0, 13, 36, 0, 37, - 0, 0, 14, 15, 0, 16, 0, 38, 39, 17, - 0, 0, 18, 0, 0, 5, 0, 0, 0, 19, + 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 8, 0, 31, 0, 0, 0, 9, 32, + 33, 34, 11, 0, 35, 0, 36, 12, 0, 0, + 37, 0, 0, 0, 0, 0, 0, 0, 14, 38, + 0, 39, 0, 0, 15, 16, 0, 17, 0, 40, + 41, 18, 0, 0, 19, 0, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 0, 21, 0, + 0, 0, 22, 0, 23, 24, 25, 26, 42, 0, + 0, 454, 0, 0, 28, 4, 5, 0, 0, 0, + 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, + 503, 0, 0, 0, 0, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 8, 0, 31, 0, + 0, 0, 9, 32, 33, 34, 11, 0, 35, 0, + 36, 12, 0, 0, 37, 0, 0, 0, 0, 0, + 0, 0, 14, 38, 0, 39, 0, 0, 15, 16, + 0, 17, 0, 40, 41, 18, 0, 0, 19, 0, + 0, 5, 0, 0, 0, 20, 0, 0, 0, 0, + 0, 0, 21, 0, 0, 0, 22, 0, 23, 24, + 25, 26, 42, 0, 0, 578, 0, 0, 28, 7, + 0, 8, 0, 0, 0, 0, 0, 9, 0, 0, + 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, + 30, 0, 0, 0, 0, 0, 0, 14, 0, 0, + 0, 0, 31, 215, 16, 0, 17, 32, 33, 34, + 18, 0, 35, 19, 36, 0, 0, 0, 37, 0, + 20, 0, 0, 0, 0, 0, 0, 38, 0, 39, + 0, 22, 0, 23, 24, 25, 26, 40, 41, 0, + 0, 0, 504, 28, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 0, 0, 0, 0, 0, 0, + 0, 515, 516, 0, 0, 0, 42, 0, 550, 681, + 4, 5, 0, 0, 0, 0, 0, 31, 0, 0, + 6, 0, 32, 33, 34, 0, 0, 35, 0, 36, + 0, 0, 0, 218, 0, 0, 0, 0, 0, 7, + 0, 8, 219, 0, 39, 0, 0, 9, 10, 0, + 0, 11, 40, 41, 0, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 0, 14, 0, 0, + 0, 0, 0, 15, 16, 0, 17, 0, 0, 0, + 18, 42, 0, 19, 572, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 0, 21, 0, 0, + 0, 22, 0, 23, 24, 25, 26, 27, 0, 0, + 0, 0, 0, 28, 0, 0, 0, 0, 29, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, + 4, 5, 0, 0, 0, 0, 0, 31, 0, 314, + 0, 0, 32, 33, 34, 0, 0, 35, 0, 36, + 0, 0, 0, 37, 0, 0, 0, 0, 0, 7, + -68, 8, 38, 0, 39, 0, 0, 9, 10, 0, + 0, 11, 40, 41, 0, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 0, 14, 0, 0, + 0, 0, 0, 15, 16, 0, 17, 0, 0, 0, + 18, 42, 0, 19, 0, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 0, 21, 315, 0, + 0, 22, 0, 23, 24, 25, 26, 27, 5, 0, + 0, 0, 0, 28, 0, 0, 0, 0, 29, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 30, 7, 0, 8, 0, + 0, 0, 0, 247, 9, 0, 0, 31, 11, 0, + 0, 0, 32, 33, 34, 0, 0, 35, 0, 36, + 0, 0, 0, 37, 14, 0, 0, 0, 0, 0, + 215, 16, 38, 17, 39, 248, 0, 18, 0, 0, + 19, 0, 40, 41, 0, 0, 0, 20, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 22, 0, + 23, 24, 25, 26, 0, 0, 0, 0, 0, 0, + 28, 42, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 8, 0, 0, 0, + 249, 247, 9, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 31, 0, 0, 0, 0, 32, + 33, 34, 14, 0, 35, 0, 36, 250, 215, 16, + 218, 17, 0, 248, 0, 18, 0, 0, 19, 219, + 0, 39, 0, 0, 0, 20, 0, 0, 0, 40, + 41, 0, 0, 0, 5, 0, 22, 0, 23, 24, + 25, 26, 0, 0, 0, 0, 0, 631, 28, 0, + 0, 0, 0, 648, 0, 0, 0, 0, 42, 0, + 0, 0, 7, 0, 8, 0, 0, 0, 249, 0, + 9, 0, 0, 0, 11, 0, 0, 0, 0, 0, + 0, 0, 31, 0, 0, 0, 0, 32, 33, 34, + 14, 0, 35, 0, 36, 250, 215, 16, 218, 17, + 0, 0, 0, 18, 0, 0, 19, 219, 0, 39, + 0, 0, 0, 20, 0, 0, 0, 40, 41, 0, + 0, 0, 5, 0, 22, 0, 23, 24, 25, 26, + 0, 0, 0, 0, 0, 661, 28, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 42, 0, 0, 0, + 7, 0, 8, 0, 0, 0, 0, 0, 9, 0, + 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, + 31, 0, 0, 0, 0, 32, 33, 34, 14, 0, + 35, 0, 36, 0, 215, 16, 218, 17, 0, 0, + 0, 18, 0, 0, 19, 219, 0, 39, 0, 0, + 0, 20, 0, 0, 0, 40, 41, 0, 0, 0, + 0, 0, 22, 0, 23, 24, 25, 26, 0, 0, + 0, 0, 0, 0, 28, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 42, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 0, 0, 31, 0, + 0, 0, 0, 32, 33, 34, 0, 0, 35, 0, + 36, 0, 0, 0, 218, 0, 0, 0, 0, 0, + 0, 0, 0, 219, 0, 39, 0, 0, 0, 0, + 0, 0, 0, 40, 41, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 0, 0, 0, 504, 0, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 0, + 0, 0, 42, 0, 0, 0, 515, 516, 0, 0, + 0, 0, 0, 597, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 495, 496, 497, 498, 499, 500, 501, + 0, 503, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 495, 496, 497, 498, 499, 500, 501, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 504, 0, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 495, 496, 497, + 498, 499, 500, 501, 515, 516, 581, 504, 0, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 495, + 496, 497, 498, 499, 500, 501, 515, 516, 670, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 504, 669, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 0, 0, 0, + 0, 0, 0, 0, 515, 516, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 504, 0, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 0, 0, 0, 0, + 0, 0, 0, 515, 516, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 0, 0, 0, 0, 0, + 0, 0, 515, 516, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 0, 0, 0, 0, 0, 0, + 0, 515, 516, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 0, + 0, 0, 5, 0, 0, 0, 515, 516, 0, 0, + 0, 0, 0, 507, 508, 509, 510, 511, 512, 513, + 514, 0, 0, 0, 0, 0, 0, 0, 515, 516, + 7, 0, 8, 0, 0, 0, 0, 0, 9, 10, + 0, 0, 11, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, + 0, 0, 0, 0, 215, 16, 0, 17, 0, 0, + 0, 18, 0, 0, 19, 7, 0, 8, 0, 0, + 0, 20, 0, 9, 0, 0, 0, 11, 0, 0, + 0, 0, 22, 0, 23, 24, 25, 26, 27, 0, + 0, 216, 0, 14, 28, 0, 0, 0, 217, 215, + 16, 0, 17, 0, 0, 0, 18, 0, 0, 19, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, - 21, 0, 22, 23, 24, 0, 40, 0, 0, 559, - 0, 26, 6, 0, 7, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 10, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 22, 31, 23, + 24, 25, 26, 32, 33, 34, 0, 0, 35, 28, + 36, 5, 0, 0, 218, 0, 0, 0, 0, 0, + 0, 0, 0, 219, 0, 39, 0, 0, 0, 0, + 0, 0, 0, 40, 41, 0, 0, 0, 0, 7, + 0, 8, 0, 31, 0, 0, 0, 9, 32, 33, + 34, 0, 0, 35, 0, 36, 0, 0, 0, 218, + 0, 0, 0, 0, 0, 0, 0, 14, 219, 0, + 39, 0, 0, 215, 16, 0, 0, 0, 40, 41, + 18, 0, 0, 19, 0, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 23, 24, 25, 26, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, - 13, 0, 0, 0, 0, 29, 208, 15, 0, 16, - 30, 31, 32, 17, 0, 33, 18, 34, 0, 0, - 0, 35, 0, 19, 0, 0, 0, 0, 0, 0, - 36, 0, 37, 0, 21, 0, 22, 23, 24, 0, - 38, 39, 0, 0, 0, 26, 0, 485, 0, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 0, - 0, 0, 4, 5, 0, 0, 496, 497, 0, 40, - 0, 300, 656, 511, 0, 0, 0, 0, 0, 29, - 0, 0, 0, 0, 30, 31, 32, 0, 0, 33, - 6, 34, 7, 0, 0, 211, 0, 0, 8, 9, - 0, 0, 10, 0, 212, 0, 37, 11, 0, 0, - 0, 0, 0, 0, 38, 39, 12, 0, 13, 0, - 0, 0, 0, 0, 14, 15, 0, 16, 0, 0, - 0, 17, 0, 0, 18, 0, 0, 0, 0, 0, - 0, 19, 0, 40, 0, 0, 553, 0, 20, 301, - 0, 0, 21, 0, 22, 23, 24, 25, 0, 0, - 0, 0, 0, 26, 0, 0, 0, 0, 27, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 4, 5, 0, 0, 0, 28, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, - 0, 0, 30, 31, 32, 0, 0, 33, 6, 34, - 7, 0, 0, 35, 0, 0, 8, 9, 0, 0, - 10, 0, 36, 0, 37, 11, 0, 0, 0, 0, - 0, 0, 38, 39, 12, 0, 13, 0, 0, 0, - 0, 0, 14, 15, 0, 16, 0, 0, 0, 17, - 0, 0, 18, 0, 0, 0, 0, 0, 0, 19, - 0, 40, 0, 0, 0, 0, 20, 0, 0, 0, - 21, 0, 22, 23, 24, 25, 0, 0, 0, 0, - 0, 26, 0, 0, 0, 0, 27, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, - 5, 0, 0, 0, 0, 29, 0, 0, 0, 0, - 30, 31, 32, 0, 0, 33, 0, 34, 0, 0, - 0, 35, 0, 0, 0, 0, 0, 6, -66, 7, - 36, 0, 37, 0, 240, 8, 0, 0, 0, 10, - 38, 39, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, - 0, 208, 15, 0, 16, 0, 241, 0, 17, 40, - 0, 18, 0, 0, 0, 0, 0, 0, 19, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, - 0, 22, 23, 24, 0, 0, 0, 0, 0, 0, - 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 242, 0, 0, 0, 0, 0, 0, 0, 5, 0, - 0, 0, 0, 0, 29, 0, 0, 0, 0, 30, - 31, 32, 0, 0, 33, 0, 34, 243, 0, 0, - 211, 0, 0, 0, 0, 6, 0, 7, 0, 212, - 0, 37, 240, 8, 0, 0, 0, 10, 0, 38, - 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 13, 0, 0, 0, 609, 0, 208, - 15, 0, 16, 0, 241, 0, 17, 0, 40, 18, - 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 21, 0, 22, - 23, 24, 0, 0, 0, 0, 0, 0, 26, 0, - 0, 5, 0, 0, 0, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 0, 0, 0, 0, 242, 626, - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 7, 0, 29, 0, 0, 0, 8, 30, 31, 32, - 10, 0, 33, 0, 34, 243, 0, 0, 211, 0, - 0, 0, 0, 0, 0, 0, 13, 212, 0, 37, - 0, 0, 208, 15, 0, 16, 0, 38, 39, 17, - 0, 0, 18, 0, 0, 5, 0, 0, 0, 19, - 0, 0, 0, 0, 0, 636, 0, 0, 0, 0, - 21, 0, 22, 23, 24, 0, 40, 0, 0, 0, - 0, 26, 6, 0, 7, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 10, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 0, 0, 0, 0, 0, 0, - 13, 0, 0, 0, 0, 29, 208, 15, 0, 16, - 30, 31, 32, 17, 0, 33, 18, 34, 0, 0, - 0, 211, 0, 19, 0, 0, 0, 0, 0, 0, - 212, 0, 37, 0, 21, 0, 22, 23, 24, 0, - 38, 39, 0, 0, 485, 26, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 0, 0, 0, 0, - 0, 0, 0, 496, 497, 0, 0, 0, 0, 40, - 531, 0, 476, 477, 478, 479, 480, 481, 482, 29, - 484, 0, 0, 0, 30, 31, 32, 0, 0, 33, - 0, 34, 0, 0, 0, 211, 0, 0, 0, 0, - 0, 0, 0, 0, 212, 0, 37, 0, 0, 0, - 0, 0, 0, 0, 38, 39, 476, 477, 478, 479, - 480, 481, 482, 483, 484, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 40, 476, 477, 478, 479, 480, 481, - 482, 483, 484, 0, 485, 0, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 0, 0, 0, 0, - 0, 0, 0, 496, 497, 0, 0, 0, 0, 0, - 575, 476, 477, 478, 479, 480, 481, 482, 483, 484, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 476, 477, 478, 479, 480, 481, 482, 483, - 484, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 476, 477, 478, 479, 480, 481, 482, 476, 477, - 478, 479, 480, 481, 482, 0, 0, 0, 0, 0, - 0, 0, 0, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 0, 0, 0, 0, 0, 0, 0, - 496, 497, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 485, 0, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 0, 0, 0, - 0, 0, 0, 0, 496, 497, 562, 0, 0, 0, - 0, 0, 0, 485, 0, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 0, 0, 0, 0, 0, - 0, 0, 496, 497, 645, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 485, 644, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 0, 0, 0, 0, 0, 0, 0, 496, - 497, 485, 0, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 0, 5, 0, 0, 0, 0, 0, - 496, 497, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 6, 0, 7, 0, 0, 496, 497, 0, 8, - 9, 0, 0, 10, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 12, 0, 13, - 0, 0, 0, 0, 0, 208, 15, 0, 16, 0, - 0, 0, 17, 0, 0, 18, 0, 0, 5, 0, - 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 21, 0, 22, 23, 24, 25, 0, - 0, 209, 0, 0, 26, 6, 0, 7, 210, 0, - 0, 0, 0, 8, 0, 0, 0, 10, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 13, 0, 0, 0, 0, 29, 208, - 15, 0, 16, 30, 31, 32, 17, 0, 33, 18, - 34, 0, 5, 0, 211, 0, 19, 0, 0, 0, - 0, 0, 0, 212, 0, 37, 0, 21, 0, 22, - 23, 24, 0, 38, 39, 0, 0, 0, 26, 6, - 0, 7, 0, 0, 0, 0, 0, 8, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, - 0, 0, 29, 208, 15, 0, 0, 30, 31, 32, - 17, 0, 33, 18, 34, 0, 0, 0, 211, 0, - 19, 0, 0, 0, 0, 0, 0, 212, 0, 37, - 0, 0, 0, 22, 23, 24, 0, 38, 39, 0, - 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 30, 31, 32, 0, 0, 33, 0, 0, 0, - 0, 0, 211, 0, 0, 0, 0, 0, 0, 0, - 0, 212, 0, 37, 0, 0, 0, 0, 0, 0, - 0, 38, 39, 101, 0, 102, 103, 104, 105, 106, - 107, 0, 108, 0, 0, 109, 0, 110, 0, 0, - 0, 111, 112, 0, 113, 114, 115, 116, 0, 117, - 118, 119, 120, 121, 122, 123, 124, 0, 125, 0, - 126, 127, 128, 129, 130, 0, 0, 131, 0, 0, - 0, 132, 0, 133, 134, 0, 135, 136, 137, 138, - 139, 140, 0, 141, 142, 143, 144, 145, 146, 0, - 0, 147, 0, 0, 148, 0, 0, 0, 0, 149, - 150, 0, 151, 152, 0, 153, 154, 0, 0, 0, - 155, 156, 157, 158, 159, 160, 0, 161, 162, 163, - 164, 165, 166, 167, 0, 168, 0, 169, 0, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 0, 0, 0, 183, 0, 0, 184, - 0, 0, 185, 186, 0, 0, 187, 188, 189, 190, - 0, 0, 191, 0, 192, 0, 193, 194, 195, 196, - 197, 198, 199, 0, 0, 200 + 0, 0, 32, 33, 34, 0, 0, 35, 0, 0, + 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, + 0, 0, 219, 0, 39, 0, 0, 0, 0, 0, + 0, 0, 40, 41, 108, 0, 109, 110, 111, 112, + 113, 114, 0, 115, 0, 0, 116, 0, 117, 0, + 0, 0, 118, 119, 0, 120, 121, 122, 123, 0, + 124, 125, 126, 127, 128, 129, 130, 131, 0, 132, + 0, 133, 134, 135, 136, 137, 0, 0, 138, 0, + 0, 0, 139, 0, 140, 141, 0, 142, 143, 144, + 145, 146, 147, 0, 148, 149, 150, 151, 152, 153, + 0, 0, 154, 0, 0, 155, 0, 0, 0, 0, + 0, 156, 157, 0, 158, 159, 0, 160, 161, 0, + 0, 0, 162, 163, 164, 165, 166, 167, 0, 168, + 169, 170, 171, 172, 173, 174, 0, 175, 0, 176, + 0, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 0, 186, 187, 188, 189, 0, 0, 0, 190, 0, + 0, 191, 0, 0, 192, 193, 0, 0, 194, 195, + 196, 197, 0, 0, 198, 0, 199, 0, 200, 201, + 202, 203, 204, 205, 206, 0, 0, 207 }; static const yytype_int16 yycheck[] = { - 2, 50, 2, 2, 71, 47, 71, 2, 272, 2, - 245, 246, 2, 2, 280, 2, 207, 50, 2, 2, - 311, 2, 2, 298, 6, 38, 330, 269, 16, 156, - 272, 249, 35, 36, 332, 58, 156, 279, 51, 182, - 282, 72, 108, 515, 99, 273, 288, 289, 276, 569, - 278, 50, 514, 281, 156, 50, 134, 50, 286, 182, - 138, 182, 93, 50, 182, 513, 209, 182, 182, 517, - 9, 335, 208, 12, 129, 3, 99, 5, 205, 574, - 207, 6, 7, 204, 579, 205, 209, 165, 44, 0, - 96, 209, 207, 335, 336, 209, 9, 332, 68, 69, - 70, 69, 70, 205, 74, 577, 74, 203, 3, 208, - 203, 39, 208, 69, 576, 208, 44, 14, 15, 16, - 17, 18, 19, 20, 366, 367, 368, 369, 370, 371, - 372, 16, 323, 208, 425, 326, 26, 203, 94, 659, - 635, 31, 614, 71, 419, 203, 437, 609, 32, 326, - 208, 203, 219, 37, 219, 207, 347, 348, 349, 3, - 608, 5, 3, 611, 5, 3, 203, 5, 207, 206, - 642, 348, 349, 203, 636, 3, 206, 5, 245, 246, - 245, 246, 203, 139, 3, 206, 5, 162, 207, 424, - 638, 258, 207, 206, 227, 151, 207, 125, 39, 647, - 267, 39, 444, 205, 206, 184, 205, 206, 211, 212, - 207, 205, 205, 206, 202, 203, 664, 9, 205, 206, - 16, 3, 207, 5, 152, 453, 3, 209, 5, 205, - 71, 280, 205, 71, 476, 477, 207, 479, 480, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 558, 497, 287, 475, 3, 290, - 5, 292, 293, 312, 192, 332, 297, 332, 559, 3, - 498, 205, 6, 7, 8, 9, 10, 11, 280, 205, - 208, 523, 3, 253, 125, 253, 207, 125, 337, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 564, 205, - 528, 207, 205, 521, 207, 202, 203, 192, 193, 194, - 608, 152, 205, 207, 152, 550, 207, 202, 203, 14, - 15, 16, 3, 372, 5, 3, 207, 5, 619, 331, - 208, 331, 331, 208, 208, 337, 70, 635, 331, 208, - 3, 390, 5, 3, 331, 5, 3, 349, 5, 647, - 3, 192, 5, 3, 192, 5, 574, 424, 3, 424, - 5, 579, 203, 208, 582, 656, 664, 208, 208, 208, - 208, 177, 178, 179, 180, 181, 207, 39, 209, 39, - 203, 208, 431, 117, 44, 452, 621, 208, 208, 207, - 439, 208, 208, 657, 190, 191, 192, 193, 194, 641, - 208, 208, 644, 208, 208, 208, 202, 203, 457, 71, - 475, 71, 205, 208, 148, 657, 207, 635, 467, 208, - 208, 208, 208, 208, 40, 208, 428, 161, 428, 428, - 208, 433, 431, 428, 436, 428, 436, 436, 428, 428, - 439, 428, 426, 436, 428, 428, 439, 428, 428, 436, - 515, 679, 439, 187, 208, 208, 190, 191, 192, 208, - 208, 195, 196, 125, 457, 125, 515, 83, 208, 208, - 204, 208, 208, 184, 208, 207, 205, 210, 209, 209, - 96, 97, 98, 550, 208, 550, 9, 9, 9, 105, - 152, 9, 152, 684, 685, 190, 191, 192, 193, 194, - 9, 543, 9, 9, 571, 554, 9, 202, 203, 574, - 9, 203, 577, 515, 579, 564, 184, 208, 207, 205, - 14, 15, 16, 17, 18, 19, 20, 207, 577, 145, - 192, 205, 192, 149, 205, 182, 209, 39, 210, 206, - 6, 203, 44, 203, 209, 209, 208, 208, 208, 182, - 209, 209, 9, 209, 621, 209, 621, 209, 209, 184, - 209, 209, 564, 209, 90, 614, 209, 209, 209, 71, - 635, 209, 209, 209, 209, 577, 202, 209, 3, 209, - 5, 6, 7, 8, 9, 10, 11, 209, 209, 209, - 209, 209, 209, 642, 207, 206, 182, 3, 207, 209, - 6, 7, 8, 9, 10, 11, 209, 32, 207, 34, - 3, 3, 614, 9, 209, 40, 6, 182, 620, 44, - 207, 620, 624, 125, 624, 624, 207, 620, 184, 209, - 209, 624, 209, 620, 209, 60, 205, 624, 209, 209, - 642, 66, 67, 209, 69, 70, 209, 209, 73, 3, - 152, 76, 6, 7, 8, 9, 10, 11, 83, 184, - 184, 207, 435, 294, 70, 288, 523, 685, 452, 94, - 433, 96, 97, 98, 50, 219, 284, -1, -1, -1, - 105, 659, -1, -1, 324, -1, -1, -1, -1, -1, - 192, -1, 117, 187, 188, 189, 190, 191, 192, 193, - 194, 203, -1, -1, -1, -1, 208, -1, 202, 203, - -1, 117, -1, -1, 139, -1, 70, -1, -1, 144, - 145, 146, -1, 148, 149, -1, 151, -1, -1, -1, - 155, -1, 14, 15, 16, -1, 161, 19, 20, 164, - -1, 166, 148, -1, -1, -1, -1, -1, -1, 174, - 175, -1, -1, -1, -1, 161, -1, -1, -1, -1, - -1, -1, 187, 117, -1, 190, 191, 192, -1, -1, - 195, 196, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 187, -1, 208, 190, 191, 192, -1, -1, 195, - 196, -1, -1, -1, 148, 4, 5, -1, 204, -1, - -1, -1, 208, -1, -1, -1, -1, 161, -1, -1, + 2, 53, 2, 2, 50, 74, 286, 2, 74, 2, + 325, 214, 2, 2, 256, 2, 252, 253, 2, 2, + 534, 2, 2, 287, 6, 75, 290, 344, 292, 72, + 73, 295, 591, 294, 77, 53, 300, 533, 39, 346, + 312, 71, 72, 73, 101, 110, 158, 77, 59, 184, + 100, 52, 184, 17, 53, 3, 596, 5, 53, 101, + 53, 601, 37, 38, 158, 184, 53, 158, 136, 349, + 28, 17, 140, 184, 206, 33, 211, 3, 184, 5, + 3, 184, 5, 205, 184, 599, 208, 206, 283, 131, + 101, 286, 40, 9, 0, 207, 12, 45, 293, 167, + 211, 296, 598, 340, 205, 211, 209, 302, 303, 210, + 346, 211, 51, 207, 40, 209, 207, 40, 205, 45, + 660, 210, 636, 210, 72, 64, 685, 442, 365, 366, + 69, 205, 97, 34, 337, 631, 210, 340, 39, 454, + 205, 179, 180, 181, 182, 183, 72, 205, 205, 72, + 3, 209, 5, 667, 349, 350, 205, 226, 9, 208, + 226, 364, 365, 366, 436, 661, 205, 3, 3, 208, + 5, 207, 3, 45, 5, 3, 210, 5, 3, 127, + 5, 210, 209, 252, 253, 164, 252, 253, 383, 384, + 385, 386, 387, 388, 389, 3, 209, 5, 70, 209, + 3, 127, 5, 272, 127, 441, 154, 208, 472, 207, + 212, 213, 281, 212, 213, 40, 234, 260, 209, 212, + 213, 209, 207, 95, 209, 212, 213, 186, 154, 211, + 260, 154, 209, 15, 16, 17, 18, 19, 20, 21, + 204, 205, 294, 218, 219, 207, 194, 72, 194, 195, + 196, 301, 494, 517, 304, 209, 306, 307, 204, 205, + 577, 311, 210, 578, 207, 207, 461, 209, 194, 141, + 3, 194, 5, 3, 326, 5, 3, 346, 5, 205, + 346, 153, 205, 547, 210, 209, 3, 210, 5, 3, + 209, 5, 294, 3, 3, 5, 5, 209, 540, 351, + 495, 496, 127, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 101, 516, 583, 630, 9, 209, 641, 211, 207, 154, + 6, 7, 209, 569, 3, 17, 207, 389, 205, 212, + 210, 210, 210, 345, 210, 345, 345, 542, 210, 351, + 210, 210, 345, 660, 596, 407, 210, 209, 345, 601, + 210, 210, 604, 210, 366, 672, 681, 210, 210, 194, + 210, 210, 441, 210, 41, 441, 210, 210, 210, 5, + 210, 210, 209, 690, 210, 210, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 210, 448, 210, 210, 210, + 210, 210, 471, 683, 456, 210, 210, 643, 190, 191, + 192, 193, 194, 195, 196, 40, 210, 84, 660, 210, + 45, 210, 204, 205, 476, 209, 211, 207, 494, 207, + 97, 98, 99, 100, 486, 186, 211, 210, 9, 9, + 107, 9, 706, 445, 9, 445, 445, 72, 450, 448, + 445, 453, 445, 453, 453, 445, 445, 456, 445, 443, + 453, 445, 445, 456, 445, 445, 453, 9, 534, 456, + 9, 666, 9, 9, 669, 9, 205, 211, 210, 186, + 147, 209, 534, 476, 151, 207, 207, 184, 683, 209, + 208, 207, 207, 212, 6, 184, 204, 15, 16, 17, + 569, 9, 127, 569, 91, 211, 211, 211, 711, 712, + 192, 193, 194, 195, 196, 210, 562, 211, 211, 211, + 211, 573, 204, 205, 593, 211, 186, 211, 211, 154, + 596, 583, 534, 599, 211, 601, 40, 211, 211, 211, + 211, 211, 208, 211, 164, 3, 211, 599, 6, 7, + 8, 9, 10, 11, 211, 211, 185, 211, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 72, 194, + 211, 211, 211, 211, 643, 204, 205, 643, 211, 209, + 205, 583, 211, 532, 636, 210, 184, 536, 211, 211, + 15, 16, 17, 209, 660, 20, 21, 599, 209, 3, + 3, 5, 6, 7, 8, 9, 10, 11, 3, 9, + 6, 211, 184, 71, 3, 667, 209, 6, 7, 8, + 9, 10, 11, 127, 205, 208, 211, 209, 5, 33, + 186, 35, 211, 211, 636, 211, 211, 41, 207, 186, + 642, 45, 209, 642, 646, 211, 646, 646, 211, 642, + 154, 211, 211, 646, 186, 642, 209, 61, 338, 646, + 452, 119, 308, 67, 68, 667, 70, 71, 302, 471, + 74, 712, 53, 77, 192, 193, 194, 195, 196, 542, + 84, 630, 71, 450, 633, 226, 204, 205, 685, 298, + 194, 95, 150, 97, 98, 99, 100, 82, 586, 584, + -1, 205, 354, 107, -1, 163, 210, -1, -1, -1, + -1, -1, -1, 3, 663, 119, 6, 7, 8, 9, + 10, 11, -1, 672, -1, -1, -1, -1, -1, -1, + 119, 189, -1, -1, 192, 193, 194, 141, -1, 197, + 198, 690, 146, 147, 148, -1, 150, 151, 206, 153, + -1, -1, 210, 157, -1, -1, -1, -1, -1, 163, + -1, 150, 166, -1, 168, 190, 191, 192, 193, 194, + 195, 196, 176, 177, 163, -1, -1, -1, -1, 204, + 205, 71, -1, -1, -1, 189, -1, -1, 192, 193, + 194, -1, -1, 197, 198, -1, -1, -1, -1, -1, + 189, -1, -1, 192, 193, 194, 210, -1, 197, 198, + -1, -1, -1, -1, -1, -1, -1, 206, -1, -1, + -1, 210, -1, -1, -1, -1, -1, -1, -1, 119, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 32, -1, 34, -1, -1, -1, -1, - -1, 40, 41, 187, -1, 44, 190, 191, 192, -1, - 49, 195, 196, -1, -1, -1, -1, -1, -1, 58, - -1, 60, -1, -1, 208, -1, -1, 66, 67, -1, - 69, -1, -1, -1, 73, -1, -1, 76, -1, -1, - -1, -1, -1, -1, 83, -1, -1, -1, -1, -1, - -1, 90, 91, -1, -1, 94, -1, 96, 97, 98, - 99, -1, -1, -1, -1, -1, 105, -1, -1, -1, - -1, 110, -1, -1, -1, -1, 188, 189, 190, 191, - 192, 193, 194, 4, 5, -1, -1, -1, 127, -1, - 202, 203, -1, -1, -1, -1, -1, -1, -1, -1, - 139, -1, -1, -1, -1, 144, 145, 146, -1, -1, - 149, 32, 151, 34, -1, -1, 155, -1, -1, 40, - 41, -1, -1, 44, -1, 164, -1, 166, 49, -1, - -1, -1, -1, -1, -1, 174, 175, 58, -1, 60, - -1, -1, -1, -1, -1, 66, 67, -1, 69, -1, - -1, -1, 73, -1, -1, 76, -1, -1, -1, -1, - -1, -1, 83, -1, 203, -1, -1, 206, -1, 90, - 91, -1, -1, 94, -1, 96, 97, 98, 99, -1, - -1, -1, -1, -1, 105, -1, -1, -1, -1, 110, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 4, 5, -1, -1, -1, 127, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 139, -1, - -1, -1, -1, 144, 145, 146, -1, -1, 149, 32, - 151, 34, -1, -1, 155, -1, -1, 40, 41, -1, - -1, 44, -1, 164, -1, 166, 49, -1, -1, -1, - -1, -1, -1, 174, 175, 58, -1, 60, -1, -1, - -1, -1, -1, 66, 67, -1, 69, -1, -1, -1, - 73, -1, -1, 76, -1, -1, -1, -1, -1, -1, - 83, -1, 203, -1, -1, 206, -1, 90, -1, -1, - -1, 94, -1, 96, 97, 98, 99, -1, -1, -1, - -1, -1, 105, -1, 4, 5, -1, 110, -1, -1, + -1, -1, -1, -1, -1, 4, 5, -1, -1, -1, + 150, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 163, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 33, -1, 35, -1, -1, -1, + -1, -1, 41, 42, -1, -1, 45, -1, -1, 189, + -1, 50, 192, 193, 194, -1, -1, 197, 198, -1, + 59, -1, 61, -1, -1, -1, -1, -1, 67, 68, + 210, 70, -1, -1, -1, 74, -1, -1, 77, -1, + -1, -1, -1, -1, -1, 84, -1, -1, -1, -1, + -1, -1, 91, 92, -1, -1, 95, -1, 97, 98, + 99, 100, 101, -1, -1, -1, -1, -1, 107, -1, + -1, -1, -1, 112, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 4, 5, -1, -1, -1, -1, + 129, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 141, -1, -1, -1, -1, 146, 147, 148, + -1, -1, 151, 33, 153, 35, -1, -1, 157, -1, + -1, 41, 42, -1, -1, 45, -1, 166, -1, 168, + 50, -1, -1, -1, -1, -1, -1, 176, 177, 59, + -1, 61, -1, -1, -1, -1, -1, 67, 68, -1, + 70, -1, -1, -1, 74, -1, -1, 77, -1, -1, + -1, -1, -1, -1, 84, -1, 205, -1, -1, 208, + -1, 91, 92, -1, -1, 95, -1, 97, 98, 99, + 100, 101, -1, -1, -1, -1, -1, 107, -1, -1, + -1, -1, 112, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 4, 5, -1, -1, -1, -1, 129, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 127, -1, -1, -1, -1, -1, - -1, -1, 32, -1, 34, -1, 139, -1, -1, -1, - 40, 144, 145, 146, 44, -1, 149, -1, 151, 49, - -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, - 60, 164, -1, 166, -1, -1, 66, 67, -1, 69, - -1, 174, 175, 73, -1, -1, 76, -1, -1, -1, - -1, -1, -1, 83, -1, -1, -1, -1, -1, -1, - 90, -1, -1, -1, 94, -1, 96, 97, 98, -1, - 203, -1, -1, 206, -1, 105, -1, 4, 5, -1, + -1, 141, -1, -1, -1, -1, 146, 147, 148, -1, + -1, 151, 33, 153, 35, -1, -1, 157, -1, -1, + 41, 42, -1, -1, 45, -1, 166, -1, 168, 50, + -1, -1, -1, -1, -1, -1, 176, 177, 59, -1, + 61, -1, -1, -1, -1, -1, 67, 68, -1, 70, + -1, -1, -1, 74, -1, -1, 77, -1, -1, -1, + -1, -1, -1, 84, -1, 205, -1, -1, 208, -1, + 91, -1, -1, -1, 95, -1, 97, 98, 99, 100, + 101, -1, -1, -1, -1, -1, 107, 4, 5, -1, + -1, 112, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 129, -1, + -1, -1, -1, -1, -1, -1, 33, -1, 35, -1, + 141, -1, -1, -1, 41, 146, 147, 148, 45, -1, + 151, -1, 153, 50, -1, -1, 157, -1, -1, -1, + -1, -1, -1, -1, 61, 166, -1, 168, -1, -1, + 67, 68, -1, 70, -1, 176, 177, 74, -1, -1, + 77, -1, -1, -1, -1, -1, -1, 84, -1, -1, + -1, -1, -1, -1, 91, -1, -1, -1, 95, -1, + 97, 98, 99, 100, 205, -1, -1, 208, -1, -1, + 107, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 127, -1, -1, - -1, -1, -1, -1, -1, 32, -1, 34, -1, 139, - -1, -1, -1, 40, 144, 145, 146, 44, -1, 149, - -1, 151, 49, -1, -1, 155, -1, -1, -1, -1, - -1, -1, -1, 60, 164, -1, 166, -1, -1, 66, - 67, -1, 69, -1, 174, 175, 73, -1, -1, 76, - -1, -1, -1, -1, -1, -1, 83, -1, -1, -1, - -1, -1, -1, 90, -1, -1, -1, 94, -1, 96, - 97, 98, -1, 203, -1, -1, 206, -1, 105, -1, - 4, 5, -1, -1, -1, -1, -1, -1, 14, 15, - 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, - 127, -1, -1, -1, -1, -1, -1, -1, 32, -1, - 34, -1, 139, -1, -1, -1, 40, 144, 145, 146, - 44, -1, 149, -1, 151, 49, -1, -1, 155, -1, - -1, -1, -1, -1, -1, -1, 60, 164, -1, 166, - -1, -1, 66, 67, -1, 69, -1, 174, 175, 73, - -1, -1, 76, -1, -1, 5, -1, -1, -1, 83, - -1, -1, -1, -1, -1, -1, 90, -1, -1, -1, - 94, -1, 96, 97, 98, -1, 203, -1, -1, 206, - -1, 105, 32, -1, 34, -1, -1, -1, -1, -1, - 40, -1, -1, -1, 44, -1, -1, -1, -1, -1, - -1, -1, -1, 127, -1, -1, -1, -1, -1, -1, - 60, -1, -1, -1, -1, 139, 66, 67, -1, 69, - 144, 145, 146, 73, -1, 149, 76, 151, -1, -1, - -1, 155, -1, 83, -1, -1, -1, -1, -1, -1, - 164, -1, 166, -1, 94, -1, 96, 97, 98, -1, - 174, 175, -1, -1, -1, 105, -1, 183, -1, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, -1, - -1, -1, 4, 5, -1, -1, 202, 203, -1, 203, - -1, 13, 206, 209, -1, -1, -1, -1, -1, 139, - -1, -1, -1, -1, 144, 145, 146, -1, -1, 149, - 32, 151, 34, -1, -1, 155, -1, -1, 40, 41, - -1, -1, 44, -1, 164, -1, 166, 49, -1, -1, - -1, -1, -1, -1, 174, 175, 58, -1, 60, -1, - -1, -1, -1, -1, 66, 67, -1, 69, -1, -1, - -1, 73, -1, -1, 76, -1, -1, -1, -1, -1, - -1, 83, -1, 203, -1, -1, 206, -1, 90, 91, - -1, -1, 94, -1, 96, 97, 98, 99, -1, -1, - -1, -1, -1, 105, -1, -1, -1, -1, 110, -1, + -1, -1, 129, -1, -1, -1, -1, -1, -1, -1, + 33, -1, 35, -1, 141, -1, -1, -1, 41, 146, + 147, 148, 45, -1, 151, -1, 153, 50, -1, -1, + 157, -1, -1, -1, -1, -1, -1, -1, 61, 166, + -1, 168, -1, -1, 67, 68, -1, 70, -1, 176, + 177, 74, -1, -1, 77, -1, -1, -1, -1, -1, + -1, 84, -1, -1, -1, -1, -1, -1, 91, -1, + -1, -1, 95, -1, 97, 98, 99, 100, 205, -1, + -1, 208, -1, -1, 107, 4, 5, -1, -1, -1, + -1, -1, 15, 16, 17, 18, 19, 20, 21, 22, + 23, -1, -1, -1, -1, -1, 129, -1, -1, -1, + -1, -1, -1, -1, 33, -1, 35, -1, 141, -1, + -1, -1, 41, 146, 147, 148, 45, -1, 151, -1, + 153, 50, -1, -1, 157, -1, -1, -1, -1, -1, + -1, -1, 61, 166, -1, 168, -1, -1, 67, 68, + -1, 70, -1, 176, 177, 74, -1, -1, 77, -1, + -1, 5, -1, -1, -1, 84, -1, -1, -1, -1, + -1, -1, 91, -1, -1, -1, 95, -1, 97, 98, + 99, 100, 205, -1, -1, 208, -1, -1, 107, 33, + -1, 35, -1, -1, -1, -1, -1, 41, -1, -1, + -1, 45, -1, -1, -1, -1, -1, -1, -1, -1, + 129, -1, -1, -1, -1, -1, -1, 61, -1, -1, + -1, -1, 141, 67, 68, -1, 70, 146, 147, 148, + 74, -1, 151, 77, 153, -1, -1, -1, 157, -1, + 84, -1, -1, -1, -1, -1, -1, 166, -1, 168, + -1, 95, -1, 97, 98, 99, 100, 176, 177, -1, + -1, -1, 185, 107, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, -1, -1, -1, -1, -1, -1, + -1, 204, 205, -1, -1, -1, 205, -1, 211, 208, + 4, 5, -1, -1, -1, -1, -1, 141, -1, -1, + 14, -1, 146, 147, 148, -1, -1, 151, -1, 153, + -1, -1, -1, 157, -1, -1, -1, -1, -1, 33, + -1, 35, 166, -1, 168, -1, -1, 41, 42, -1, + -1, 45, 176, 177, -1, -1, 50, -1, -1, -1, + -1, -1, -1, -1, -1, 59, -1, 61, -1, -1, + -1, -1, -1, 67, 68, -1, 70, -1, -1, -1, + 74, 205, -1, 77, 208, -1, -1, -1, -1, -1, + 84, -1, -1, -1, -1, -1, -1, 91, -1, -1, + -1, 95, -1, 97, 98, 99, 100, 101, -1, -1, + -1, -1, -1, 107, -1, -1, -1, -1, 112, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 4, 5, -1, -1, -1, 127, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 139, -1, -1, - -1, -1, 144, 145, 146, -1, -1, 149, 32, 151, - 34, -1, -1, 155, -1, -1, 40, 41, -1, -1, - 44, -1, 164, -1, 166, 49, -1, -1, -1, -1, - -1, -1, 174, 175, 58, -1, 60, -1, -1, -1, - -1, -1, 66, 67, -1, 69, -1, -1, -1, 73, - -1, -1, 76, -1, -1, -1, -1, -1, -1, 83, - -1, 203, -1, -1, -1, -1, 90, -1, -1, -1, - 94, -1, 96, 97, 98, 99, -1, -1, -1, -1, - -1, 105, -1, -1, -1, -1, 110, -1, -1, -1, + -1, -1, -1, -1, -1, 129, -1, -1, -1, -1, + 4, 5, -1, -1, -1, -1, -1, 141, -1, 13, + -1, -1, 146, 147, 148, -1, -1, 151, -1, 153, + -1, -1, -1, 157, -1, -1, -1, -1, -1, 33, + 164, 35, 166, -1, 168, -1, -1, 41, 42, -1, + -1, 45, 176, 177, -1, -1, 50, -1, -1, -1, + -1, -1, -1, -1, -1, 59, -1, 61, -1, -1, + -1, -1, -1, 67, 68, -1, 70, -1, -1, -1, + 74, 205, -1, 77, -1, -1, -1, -1, -1, -1, + 84, -1, -1, -1, -1, -1, -1, 91, 92, -1, + -1, 95, -1, 97, 98, 99, 100, 101, 5, -1, + -1, -1, -1, 107, -1, -1, -1, -1, 112, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 127, -1, -1, -1, -1, -1, -1, - 5, -1, -1, -1, -1, 139, -1, -1, -1, -1, - 144, 145, 146, -1, -1, 149, -1, 151, -1, -1, - -1, 155, -1, -1, -1, -1, -1, 32, 162, 34, - 164, -1, 166, -1, 39, 40, -1, -1, -1, 44, - 174, 175, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 60, -1, -1, -1, -1, - -1, 66, 67, -1, 69, -1, 71, -1, 73, 203, - -1, 76, -1, -1, -1, -1, -1, -1, 83, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 94, - -1, 96, 97, 98, -1, -1, -1, -1, -1, -1, - 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 129, 33, -1, 35, -1, + -1, -1, -1, 40, 41, -1, -1, 141, 45, -1, + -1, -1, 146, 147, 148, -1, -1, 151, -1, 153, + -1, -1, -1, 157, 61, -1, -1, -1, -1, -1, + 67, 68, 166, 70, 168, 72, -1, 74, -1, -1, + 77, -1, 176, 177, -1, -1, -1, 84, -1, -1, + -1, -1, -1, -1, -1, -1, 5, -1, 95, -1, + 97, 98, 99, 100, -1, -1, -1, -1, -1, -1, + 107, 205, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 33, -1, 35, -1, -1, -1, + 127, 40, 41, -1, -1, -1, 45, -1, -1, -1, + -1, -1, -1, -1, 141, -1, -1, -1, -1, 146, + 147, 148, 61, -1, 151, -1, 153, 154, 67, 68, + 157, 70, -1, 72, -1, 74, -1, -1, 77, 166, + -1, 168, -1, -1, -1, 84, -1, -1, -1, 176, + 177, -1, -1, -1, 5, -1, 95, -1, 97, 98, + 99, 100, -1, -1, -1, -1, -1, 194, 107, -1, + -1, -1, -1, 24, -1, -1, -1, -1, 205, -1, + -1, -1, 33, -1, 35, -1, -1, -1, 127, -1, + 41, -1, -1, -1, 45, -1, -1, -1, -1, -1, + -1, -1, 141, -1, -1, -1, -1, 146, 147, 148, + 61, -1, 151, -1, 153, 154, 67, 68, 157, 70, + -1, -1, -1, 74, -1, -1, 77, 166, -1, 168, + -1, -1, -1, 84, -1, -1, -1, 176, 177, -1, + -1, -1, 5, -1, 95, -1, 97, 98, 99, 100, + -1, -1, -1, -1, -1, 194, 107, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 205, -1, -1, -1, + 33, -1, 35, -1, -1, -1, -1, -1, 41, -1, + -1, -1, 45, -1, -1, -1, -1, -1, -1, -1, + 141, -1, -1, -1, -1, 146, 147, 148, 61, -1, + 151, -1, 153, -1, 67, 68, 157, 70, -1, -1, + -1, 74, -1, -1, 77, 166, -1, 168, -1, -1, + -1, 84, -1, -1, -1, 176, 177, -1, -1, -1, + -1, -1, 95, -1, 97, 98, 99, 100, -1, -1, + -1, -1, -1, -1, 107, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 205, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 15, 16, 17, + 18, 19, 20, 21, 22, 23, -1, -1, 141, -1, + -1, -1, -1, 146, 147, 148, -1, -1, 151, -1, + 153, -1, -1, -1, 157, -1, -1, -1, -1, -1, + -1, -1, -1, 166, -1, 168, -1, -1, -1, -1, + -1, -1, -1, 176, 177, 15, 16, 17, 18, 19, + 20, 21, 22, 23, -1, -1, -1, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, -1, + -1, -1, 205, -1, -1, -1, 204, 205, -1, -1, + -1, -1, -1, 211, 15, 16, 17, 18, 19, 20, + 21, 22, 23, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + -1, 23, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 125, -1, -1, -1, -1, -1, -1, -1, 5, -1, - -1, -1, -1, -1, 139, -1, -1, -1, -1, 144, - 145, 146, -1, -1, 149, -1, 151, 152, -1, -1, - 155, -1, -1, -1, -1, 32, -1, 34, -1, 164, - -1, 166, 39, 40, -1, -1, -1, 44, -1, 174, - 175, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 60, -1, -1, -1, 192, -1, 66, - 67, -1, 69, -1, 71, -1, 73, -1, 203, 76, - -1, -1, -1, -1, -1, -1, 83, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 94, -1, 96, - 97, 98, -1, -1, -1, -1, -1, -1, 105, -1, - -1, 5, -1, -1, -1, 14, 15, 16, 17, 18, - 19, 20, 21, 22, -1, -1, -1, -1, 125, 23, - -1, -1, -1, -1, -1, -1, -1, -1, 32, -1, - 34, -1, 139, -1, -1, -1, 40, 144, 145, 146, - 44, -1, 149, -1, 151, 152, -1, -1, 155, -1, - -1, -1, -1, -1, -1, -1, 60, 164, -1, 166, - -1, -1, 66, 67, -1, 69, -1, 174, 175, 73, - -1, -1, 76, -1, -1, 5, -1, -1, -1, 83, - -1, -1, -1, -1, -1, 192, -1, -1, -1, -1, - 94, -1, 96, 97, 98, -1, 203, -1, -1, -1, - -1, 105, 32, -1, 34, -1, -1, -1, -1, -1, - 40, -1, -1, -1, 44, 14, 15, 16, 17, 18, - 19, 20, 21, 22, -1, -1, -1, -1, -1, -1, - 60, -1, -1, -1, -1, 139, 66, 67, -1, 69, - 144, 145, 146, 73, -1, 149, 76, 151, -1, -1, - -1, 155, -1, 83, -1, -1, -1, -1, -1, -1, - 164, -1, 166, -1, 94, -1, 96, 97, 98, -1, - 174, 175, -1, -1, 183, 105, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, -1, -1, -1, -1, - -1, -1, -1, 202, 203, -1, -1, -1, -1, 203, - 209, -1, 14, 15, 16, 17, 18, 19, 20, 139, - 22, -1, -1, -1, 144, 145, 146, -1, -1, 149, - -1, 151, -1, -1, -1, 155, -1, -1, -1, -1, - -1, -1, -1, -1, 164, -1, 166, -1, -1, -1, - -1, -1, -1, -1, 174, 175, 14, 15, 16, 17, - 18, 19, 20, 21, 22, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 15, 16, 17, + 18, 19, 20, 21, 204, 205, 206, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 15, + 16, 17, 18, 19, 20, 21, 204, 205, 206, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 203, 14, 15, 16, 17, 18, 19, - 20, 21, 22, -1, 183, -1, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, -1, -1, -1, -1, - -1, -1, -1, 202, 203, -1, -1, -1, -1, -1, - 209, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 14, 15, 16, 17, 18, 19, 20, 21, - 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 14, 15, 16, 17, 18, 19, 20, 14, 15, - 16, 17, 18, 19, 20, -1, -1, -1, -1, -1, - -1, -1, -1, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, -1, -1, -1, -1, -1, -1, -1, - 202, 203, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, -1, -1, -1, + -1, -1, -1, -1, 204, 205, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 183, -1, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, -1, -1, -1, - -1, -1, -1, -1, 202, 203, 204, -1, -1, -1, - -1, -1, -1, 183, -1, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, -1, -1, -1, -1, -1, - -1, -1, 202, 203, 204, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, -1, -1, -1, -1, + -1, -1, -1, 204, 205, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, -1, -1, -1, -1, -1, + -1, -1, 204, 205, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, -1, -1, -1, -1, -1, -1, + -1, 204, 205, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, -1, -1, -1, -1, -1, -1, -1, 202, - 203, 183, -1, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, -1, 5, -1, -1, -1, -1, -1, - 202, 203, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 188, 189, 190, 191, 192, 193, 194, 202, - 203, 32, -1, 34, -1, -1, 202, 203, -1, 40, - 41, -1, -1, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 58, -1, 60, - -1, -1, -1, -1, -1, 66, 67, -1, 69, -1, - -1, -1, 73, -1, -1, 76, -1, -1, 5, -1, - -1, -1, 83, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 94, -1, 96, 97, 98, 99, -1, - -1, 102, -1, -1, 105, 32, -1, 34, 109, -1, - -1, -1, -1, 40, -1, -1, -1, 44, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 60, -1, -1, -1, -1, 139, 66, - 67, -1, 69, 144, 145, 146, 73, -1, 149, 76, - 151, -1, 5, -1, 155, -1, 83, -1, -1, -1, - -1, -1, -1, 164, -1, 166, -1, 94, -1, 96, - 97, 98, -1, 174, 175, -1, -1, -1, 105, 32, - -1, 34, -1, -1, -1, -1, -1, 40, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 60, -1, -1, - -1, -1, 139, 66, 67, -1, -1, 144, 145, 146, - 73, -1, 149, 76, 151, -1, -1, -1, 155, -1, - 83, -1, -1, -1, -1, -1, -1, 164, -1, 166, - -1, -1, -1, 96, 97, 98, -1, 174, 175, -1, - -1, -1, 105, -1, -1, -1, -1, -1, -1, -1, + 188, 189, 190, 191, 192, 193, 194, 195, 196, -1, + -1, -1, 5, -1, -1, -1, 204, 205, -1, -1, + -1, -1, -1, 189, 190, 191, 192, 193, 194, 195, + 196, -1, -1, -1, -1, -1, -1, -1, 204, 205, + 33, -1, 35, -1, -1, -1, -1, -1, 41, 42, + -1, -1, 45, -1, -1, -1, -1, 5, -1, -1, + -1, -1, -1, -1, -1, -1, 59, -1, 61, -1, + -1, -1, -1, -1, 67, 68, -1, 70, -1, -1, + -1, 74, -1, -1, 77, 33, -1, 35, -1, -1, + -1, 84, -1, 41, -1, -1, -1, 45, -1, -1, + -1, -1, 95, -1, 97, 98, 99, 100, 101, -1, + -1, 104, -1, 61, 107, -1, -1, -1, 111, 67, + 68, -1, 70, -1, -1, -1, 74, -1, -1, 77, + -1, -1, -1, -1, -1, -1, 84, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 95, 141, 97, + 98, 99, 100, 146, 147, 148, -1, -1, 151, 107, + 153, 5, -1, -1, 157, -1, -1, -1, -1, -1, + -1, -1, -1, 166, -1, 168, -1, -1, -1, -1, + -1, -1, -1, 176, 177, -1, -1, -1, -1, 33, + -1, 35, -1, 141, -1, -1, -1, 41, 146, 147, + 148, -1, -1, 151, -1, 153, -1, -1, -1, 157, + -1, -1, -1, -1, -1, -1, -1, 61, 166, -1, + 168, -1, -1, 67, 68, -1, -1, -1, 176, 177, + 74, -1, -1, 77, -1, -1, -1, -1, -1, -1, + 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 97, 98, 99, 100, -1, -1, -1, + -1, -1, -1, 107, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 144, 145, 146, -1, -1, 149, -1, -1, -1, - -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, - -1, 164, -1, 166, -1, -1, -1, -1, -1, -1, - -1, 174, 175, 24, -1, 26, 27, 28, 29, 30, - 31, -1, 33, -1, -1, 36, -1, 38, -1, -1, - -1, 42, 43, -1, 45, 46, 47, 48, -1, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, -1, - 61, 62, 63, 64, 65, -1, -1, 68, -1, -1, - -1, 72, -1, 74, 75, -1, 77, 78, 79, 80, - 81, 82, -1, 84, 85, 86, 87, 88, 89, -1, - -1, 92, -1, -1, 95, -1, -1, -1, -1, 100, - 101, -1, 103, 104, -1, 106, 107, -1, -1, -1, - 111, 112, 113, 114, 115, 116, -1, 118, 119, 120, - 121, 122, 123, 124, -1, 126, -1, 128, -1, 130, - 131, 132, 133, 134, 135, 136, 137, 138, -1, 140, - 141, 142, 143, -1, -1, -1, 147, -1, -1, 150, - -1, -1, 153, 154, -1, -1, 157, 158, 159, 160, - -1, -1, 163, -1, 165, -1, 167, 168, 169, 170, - 171, 172, 173, -1, -1, 176 + -1, -1, 146, 147, 148, -1, -1, 151, -1, -1, + -1, -1, -1, 157, -1, -1, -1, -1, -1, -1, + -1, -1, 166, -1, 168, -1, -1, -1, -1, -1, + -1, -1, 176, 177, 25, -1, 27, 28, 29, 30, + 31, 32, -1, 34, -1, -1, 37, -1, 39, -1, + -1, -1, 43, 44, -1, 46, 47, 48, 49, -1, + 51, 52, 53, 54, 55, 56, 57, 58, -1, 60, + -1, 62, 63, 64, 65, 66, -1, -1, 69, -1, + -1, -1, 73, -1, 75, 76, -1, 78, 79, 80, + 81, 82, 83, -1, 85, 86, 87, 88, 89, 90, + -1, -1, 93, -1, -1, 96, -1, -1, -1, -1, + -1, 102, 103, -1, 105, 106, -1, 108, 109, -1, + -1, -1, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, 126, -1, 128, -1, 130, + -1, 132, 133, 134, 135, 136, 137, 138, 139, 140, + -1, 142, 143, 144, 145, -1, -1, -1, 149, -1, + -1, 152, -1, -1, 155, 156, -1, -1, 159, 160, + 161, 162, -1, -1, 165, -1, 167, -1, 169, 170, + 171, 172, 173, 174, 175, -1, -1, 178 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint16 yystos[] = { - 0, 212, 213, 0, 4, 5, 32, 34, 40, 41, - 44, 49, 58, 60, 66, 67, 69, 73, 76, 83, - 90, 94, 96, 97, 98, 99, 105, 110, 127, 139, - 144, 145, 146, 149, 151, 155, 164, 166, 174, 175, - 203, 219, 220, 222, 223, 224, 225, 228, 229, 235, - 236, 247, 261, 265, 267, 268, 269, 270, 271, 274, - 275, 278, 280, 281, 282, 283, 285, 286, 287, 288, - 289, 291, 293, 311, 312, 313, 314, 3, 5, 208, - 3, 5, 3, 5, 263, 96, 266, 9, 3, 5, - 266, 3, 208, 208, 266, 267, 3, 263, 3, 263, - 267, 24, 26, 27, 28, 29, 30, 31, 33, 36, - 38, 42, 43, 45, 46, 47, 48, 50, 51, 52, - 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, - 65, 68, 72, 74, 75, 77, 78, 79, 80, 81, - 82, 84, 85, 86, 87, 88, 89, 92, 95, 100, - 101, 103, 104, 106, 107, 111, 112, 113, 114, 115, - 116, 118, 119, 120, 121, 122, 123, 124, 126, 128, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 140, - 141, 142, 143, 147, 150, 153, 154, 157, 158, 159, - 160, 163, 165, 167, 168, 169, 170, 171, 172, 173, - 176, 237, 239, 310, 207, 215, 215, 162, 66, 102, - 109, 155, 164, 227, 247, 268, 274, 280, 284, 291, - 311, 314, 207, 207, 205, 205, 207, 205, 207, 218, - 207, 184, 279, 205, 292, 293, 292, 292, 3, 5, - 39, 71, 125, 152, 192, 208, 241, 264, 294, 295, - 308, 247, 311, 312, 314, 292, 207, 9, 205, 207, - 3, 312, 205, 156, 205, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, 182, 204, - 13, 91, 219, 226, 229, 268, 270, 271, 282, 283, - 286, 206, 235, 236, 3, 3, 5, 3, 5, 3, - 3, 205, 308, 272, 214, 129, 276, 280, 3, 5, - 205, 217, 290, 294, 294, 210, 203, 208, 234, 292, - 209, 244, 245, 246, 264, 184, 209, 254, 208, 257, - 9, 9, 12, 240, 264, 3, 6, 7, 8, 9, - 10, 11, 70, 117, 148, 161, 187, 190, 191, 192, - 195, 196, 208, 250, 251, 252, 250, 253, 9, 9, - 238, 253, 252, 9, 9, 252, 9, 252, 250, 233, - 236, 291, 252, 248, 249, 250, 9, 310, 9, 252, - 312, 248, 250, 312, 177, 178, 179, 180, 181, 309, - 312, 312, 240, 6, 7, 315, 9, 312, 239, 203, - 208, 207, 205, 218, 291, 206, 235, 273, 213, 184, - 108, 235, 259, 277, 207, 205, 217, 206, 219, 236, - 289, 294, 209, 253, 192, 204, 250, 230, 231, 232, - 233, 206, 182, 210, 6, 221, 206, 235, 255, 259, - 206, 236, 256, 259, 209, 209, 209, 208, 250, 250, - 250, 250, 250, 250, 250, 291, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 183, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 202, 203, 182, 209, - 209, 209, 182, 209, 209, 209, 209, 209, 209, 209, - 209, 209, 209, 291, 192, 208, 234, 241, 264, 300, - 302, 303, 209, 182, 209, 209, 209, 209, 182, 209, - 209, 209, 209, 209, 209, 209, 209, 202, 209, 209, - 209, 239, 9, 216, 294, 304, 218, 283, 206, 184, - 291, 311, 207, 206, 236, 260, 261, 206, 225, 206, - 218, 204, 204, 209, 182, 246, 252, 6, 209, 291, - 314, 209, 207, 207, 291, 209, 192, 208, 234, 241, - 296, 298, 299, 250, 250, 3, 250, 250, 250, 250, - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, - 250, 250, 250, 3, 250, 252, 9, 302, 290, 192, - 230, 241, 301, 302, 208, 234, 249, 252, 6, 209, - 215, 182, 294, 207, 217, 218, 23, 233, 300, 306, - 307, 207, 262, 264, 298, 290, 192, 230, 241, 297, - 298, 209, 208, 234, 184, 204, 302, 290, 209, 302, - 209, 230, 209, 218, 206, 294, 206, 184, 305, 182, - 207, 205, 209, 298, 290, 209, 302, 209, 250, 230, - 250, 302, 209, 218, 253, 306, 242, 302, 209, 38, - 51, 206, 243, 252, 184, 184, 207, 258, 259, 258, - 207 + 0, 214, 216, 0, 4, 5, 14, 33, 35, 41, + 42, 45, 50, 59, 61, 67, 68, 70, 74, 77, + 84, 91, 95, 97, 98, 99, 100, 101, 107, 112, + 129, 141, 146, 147, 148, 151, 153, 157, 166, 168, + 176, 177, 205, 215, 222, 223, 225, 226, 227, 228, + 231, 232, 238, 239, 250, 264, 268, 270, 271, 272, + 273, 274, 277, 278, 281, 283, 284, 285, 286, 288, + 289, 290, 291, 292, 294, 296, 314, 315, 316, 317, + 205, 319, 322, 323, 3, 5, 210, 3, 5, 3, + 5, 266, 97, 269, 9, 3, 5, 269, 3, 210, + 210, 269, 270, 3, 266, 3, 266, 270, 25, 27, + 28, 29, 30, 31, 32, 34, 37, 39, 43, 44, + 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, + 57, 58, 60, 62, 63, 64, 65, 66, 69, 73, + 75, 76, 78, 79, 80, 81, 82, 83, 85, 86, + 87, 88, 89, 90, 93, 96, 102, 103, 105, 106, + 108, 109, 113, 114, 115, 116, 117, 118, 120, 121, + 122, 123, 124, 125, 126, 128, 130, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 142, 143, 144, 145, + 149, 152, 155, 156, 159, 160, 161, 162, 165, 167, + 169, 170, 171, 172, 173, 174, 175, 178, 240, 242, + 313, 209, 218, 218, 164, 67, 104, 111, 157, 166, + 230, 250, 271, 277, 283, 287, 294, 314, 317, 209, + 209, 207, 207, 209, 207, 209, 221, 209, 186, 282, + 207, 295, 296, 295, 295, 3, 5, 40, 72, 127, + 154, 194, 210, 244, 267, 297, 298, 311, 250, 314, + 315, 317, 295, 209, 51, 64, 69, 324, 325, 319, + 101, 9, 207, 209, 3, 315, 207, 158, 207, 210, + 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, + 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, + 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, + 210, 210, 184, 206, 13, 92, 222, 229, 232, 271, + 273, 274, 285, 286, 289, 208, 238, 239, 3, 3, + 5, 3, 5, 3, 3, 207, 311, 275, 217, 131, + 279, 283, 3, 5, 207, 220, 293, 297, 297, 212, + 205, 210, 237, 295, 184, 206, 5, 211, 247, 248, + 249, 267, 186, 211, 257, 210, 260, 9, 9, 12, + 243, 267, 3, 6, 7, 8, 9, 10, 11, 71, + 119, 150, 163, 189, 192, 193, 194, 197, 198, 210, + 253, 254, 255, 253, 256, 9, 9, 241, 256, 255, + 9, 9, 255, 9, 255, 253, 236, 239, 294, 255, + 251, 252, 253, 9, 313, 9, 255, 315, 251, 253, + 315, 179, 180, 181, 182, 183, 312, 315, 315, 243, + 6, 7, 318, 9, 315, 242, 205, 210, 209, 207, + 221, 294, 208, 238, 276, 216, 186, 110, 238, 262, + 280, 209, 207, 220, 208, 222, 239, 292, 297, 211, + 256, 194, 206, 253, 233, 234, 235, 236, 325, 207, + 208, 184, 212, 6, 224, 208, 238, 258, 262, 208, + 239, 259, 262, 211, 211, 211, 210, 253, 253, 253, + 253, 253, 253, 253, 294, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 185, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 204, 205, 184, 211, 211, + 211, 184, 211, 211, 211, 211, 211, 211, 211, 211, + 211, 211, 294, 194, 210, 237, 244, 267, 303, 305, + 306, 211, 184, 211, 211, 211, 211, 184, 211, 211, + 211, 211, 211, 211, 211, 211, 204, 211, 211, 211, + 242, 9, 219, 297, 307, 221, 286, 208, 186, 294, + 314, 209, 208, 239, 263, 264, 208, 228, 208, 221, + 206, 206, 211, 184, 164, 320, 321, 249, 255, 6, + 211, 294, 317, 211, 209, 209, 294, 211, 194, 210, + 237, 244, 299, 301, 302, 253, 253, 3, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, + 253, 253, 253, 253, 253, 3, 253, 255, 9, 305, + 293, 194, 233, 244, 304, 305, 210, 237, 252, 255, + 6, 211, 218, 184, 297, 209, 220, 221, 24, 236, + 323, 208, 320, 303, 309, 310, 209, 265, 267, 301, + 293, 194, 233, 244, 300, 301, 211, 210, 237, 186, + 206, 305, 293, 211, 305, 211, 233, 211, 221, 208, + 297, 208, 5, 186, 308, 184, 209, 207, 211, 301, + 293, 211, 305, 211, 253, 233, 253, 305, 211, 221, + 209, 256, 309, 245, 305, 211, 39, 52, 208, 246, + 255, 186, 186, 209, 261, 262, 261, 209 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 211, 212, 213, 214, 213, 213, 213, 213, 213, - 213, 213, 213, 215, 215, 216, 215, 215, 215, 215, - 215, 215, 215, 215, 217, 217, 218, 218, 219, 219, - 219, 219, 219, 219, 219, 220, 221, 221, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 223, 224, 225, - 226, 227, 227, 228, 229, 230, 230, 231, 231, 232, - 232, 233, 233, 234, 234, 234, 235, 235, 236, 237, - 237, 237, 238, 238, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 240, 240, 241, 241, 241, 241, - 242, 242, 243, 243, 244, 244, 244, 245, 245, 246, - 246, 247, 248, 248, 249, 249, 250, 250, 250, 250, - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, - 250, 250, 250, 250, 250, 250, 250, 251, 251, 252, - 253, 254, 254, 255, 255, 256, 256, 257, 257, 258, - 258, 259, 259, 260, 261, 261, 262, 262, 263, 263, - 263, 264, 264, 265, 265, 265, 265, 265, 265, 265, - 265, 265, 265, 265, 266, 266, 267, 267, 267, 267, - 267, 267, 267, 267, 268, 268, 269, 270, 271, 272, - 272, 273, 274, 274, 275, 276, 276, 277, 277, 278, - 278, 279, 279, 280, 280, 281, 282, 282, 282, 283, - 283, 284, 284, 285, 286, 287, 287, 287, 288, 289, - 290, 290, 291, 291, 292, 292, 293, 293, 293, 294, - 294, 294, 295, 295, 295, 295, 296, 296, 296, 297, - 297, 298, 298, 299, 299, 299, 299, 299, 300, 300, - 300, 301, 301, 302, 302, 303, 303, 303, 303, 303, - 303, 304, 304, 305, 305, 306, 307, 307, 308, 308, - 309, 309, 309, 309, 309, 310, 310, 310, 311, 312, - 312, 312, 312, 312, 312, 312, 312, 312, 312, 313, - 314, 314, 315, 315, 315 + 0, 213, 214, 215, 215, 216, 217, 216, 216, 216, + 216, 216, 216, 216, 216, 218, 218, 219, 218, 218, + 218, 218, 218, 218, 218, 218, 220, 220, 221, 221, + 222, 222, 222, 222, 222, 222, 222, 223, 224, 224, + 225, 225, 225, 225, 225, 225, 225, 225, 225, 226, + 227, 228, 229, 230, 230, 231, 232, 233, 233, 234, + 234, 235, 235, 236, 236, 237, 237, 237, 238, 238, + 239, 240, 240, 240, 241, 241, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 243, 243, 244, 244, + 244, 244, 245, 245, 246, 246, 247, 247, 247, 248, + 248, 249, 249, 250, 251, 251, 252, 252, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 254, + 254, 255, 256, 257, 257, 258, 258, 259, 259, 260, + 260, 261, 261, 262, 262, 263, 264, 264, 265, 265, + 266, 266, 266, 267, 267, 268, 268, 268, 268, 268, + 268, 268, 268, 268, 268, 268, 269, 269, 270, 270, + 270, 270, 270, 270, 270, 270, 270, 271, 271, 272, + 273, 274, 275, 275, 276, 277, 277, 278, 279, 279, + 280, 280, 281, 281, 282, 282, 283, 283, 284, 285, + 285, 285, 286, 286, 287, 287, 288, 289, 290, 290, + 290, 291, 292, 293, 293, 294, 294, 295, 295, 296, + 296, 296, 297, 297, 297, 298, 298, 298, 298, 299, + 299, 299, 300, 300, 301, 301, 302, 302, 302, 302, + 302, 303, 303, 303, 304, 304, 305, 305, 306, 306, + 306, 306, 306, 306, 307, 307, 308, 308, 309, 310, + 310, 311, 311, 312, 312, 312, 312, 312, 313, 313, + 313, 314, 315, 315, 315, 315, 315, 315, 315, 315, + 315, 315, 316, 317, 317, 318, 318, 318, 319, 319, + 320, 320, 321, 322, 323, 323, 324, 324, 325, 325, + 325 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { - 0, 2, 1, 0, 0, 6, 2, 2, 3, 2, - 2, 2, 2, 0, 2, 0, 6, 2, 3, 2, - 2, 2, 2, 2, 0, 2, 0, 1, 1, 2, - 2, 1, 2, 1, 1, 6, 1, 2, 1, 2, - 1, 2, 1, 2, 2, 2, 2, 4, 3, 3, - 5, 2, 2, 3, 4, 0, 1, 1, 3, 1, - 3, 3, 2, 3, 3, 2, 0, 1, 3, 1, - 3, 4, 1, 3, 0, 1, 4, 1, 1, 1, - 1, 1, 4, 4, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 4, 1, 1, 1, 4, 1, - 1, 1, 4, 4, 1, 1, 1, 1, 4, 4, - 4, 4, 4, 1, 4, 1, 1, 4, 1, 4, - 1, 1, 4, 4, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, - 1, 1, 4, 4, 1, 1, 1, 1, 1, 6, - 1, 4, 1, 1, 1, 4, 1, 1, 1, 4, - 4, 4, 4, 1, 1, 4, 4, 4, 1, 1, - 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, - 0, 2, 4, 3, 0, 2, 1, 1, 3, 3, - 1, 5, 1, 3, 0, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 5, 3, 3, 3, + 0, 2, 2, 0, 2, 0, 0, 6, 2, 2, + 3, 2, 2, 2, 2, 0, 2, 0, 6, 2, + 3, 2, 2, 2, 2, 2, 0, 2, 0, 1, + 1, 2, 2, 1, 2, 1, 1, 6, 1, 2, + 1, 2, 1, 2, 1, 2, 2, 2, 2, 4, + 3, 3, 5, 2, 2, 3, 4, 0, 1, 1, + 3, 1, 3, 3, 2, 3, 3, 2, 0, 1, + 3, 1, 3, 4, 1, 3, 0, 1, 4, 1, + 1, 1, 1, 1, 4, 4, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, + 4, 1, 1, 1, 4, 4, 1, 1, 1, 1, + 4, 4, 4, 4, 4, 1, 4, 1, 1, 4, + 1, 4, 1, 1, 4, 4, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 4, 1, 1, 1, 4, 4, 1, 1, 1, 1, + 1, 6, 1, 4, 1, 1, 1, 4, 1, 1, + 1, 4, 4, 4, 4, 1, 1, 4, 4, 4, + 1, 1, 4, 4, 4, 1, 1, 1, 1, 1, + 1, 1, 0, 2, 4, 3, 0, 2, 1, 1, + 3, 3, 1, 5, 1, 3, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, - 2, 3, 3, 5, 5, 4, 3, 1, 3, 1, - 1, 0, 2, 4, 3, 2, 2, 0, 2, 2, - 1, 3, 2, 1, 3, 2, 0, 1, 0, 1, - 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, - 1, 1, 1, 1, 0, 1, 1, 2, 1, 2, - 2, 1, 1, 1, 2, 2, 2, 5, 2, 0, - 2, 2, 2, 2, 2, 2, 3, 2, 3, 5, - 5, 0, 2, 2, 2, 2, 6, 8, 2, 2, - 2, 2, 2, 2, 5, 1, 1, 1, 1, 1, - 0, 2, 2, 3, 0, 1, 2, 2, 2, 3, - 2, 1, 1, 3, 2, 4, 3, 2, 1, 3, - 2, 0, 1, 3, 2, 1, 3, 4, 3, 2, - 1, 3, 2, 0, 1, 1, 3, 2, 1, 3, - 4, 1, 3, 0, 2, 2, 1, 3, 1, 3, - 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, - 1, 1, 1, 2, 1, 2, 1, 2, 4, 5, - 5, 10, 1, 3, 1 + 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, + 2, 2, 2, 3, 3, 5, 5, 4, 3, 1, + 3, 1, 1, 0, 2, 4, 3, 2, 2, 0, + 2, 2, 1, 3, 2, 1, 3, 2, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, + 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, + 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, + 5, 2, 0, 2, 2, 2, 2, 2, 2, 3, + 2, 3, 5, 5, 0, 2, 2, 2, 2, 6, + 8, 2, 2, 2, 2, 2, 2, 5, 1, 1, + 1, 1, 1, 0, 2, 2, 3, 0, 1, 2, + 2, 2, 3, 2, 1, 1, 3, 2, 4, 3, + 2, 1, 3, 2, 0, 1, 3, 2, 1, 3, + 4, 3, 2, 1, 3, 2, 0, 1, 1, 3, + 2, 1, 3, 4, 1, 3, 0, 2, 2, 1, + 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, + 1, 5, 1, 1, 1, 1, 2, 1, 2, 1, + 2, 4, 5, 5, 10, 1, 3, 1, 0, 2, + 0, 2, 4, 6, 0, 3, 1, 3, 1, 1, + 1 }; @@ -2564,210 +2598,213 @@ yyreduce: switch (yyn) { case 2: -#line 321 "parser.y" /* yacc.c:1646 */ +#line 327 "parser.y" /* yacc.c:1646 */ { fix_incomplete(); - check_statements((yyvsp[0].stmt_list), FALSE); - check_all_user_types((yyvsp[0].stmt_list)); - write_header((yyvsp[0].stmt_list)); - write_id_data((yyvsp[0].stmt_list)); - write_proxies((yyvsp[0].stmt_list)); - write_client((yyvsp[0].stmt_list)); - write_server((yyvsp[0].stmt_list)); - write_regscript((yyvsp[0].stmt_list)); - write_dlldata((yyvsp[0].stmt_list)); - write_local_stubs((yyvsp[0].stmt_list)); + check_statements((yyvsp[-1].stmt_list), FALSE); + check_all_user_types((yyvsp[-1].stmt_list)); + write_header((yyvsp[-1].stmt_list)); + write_id_data((yyvsp[-1].stmt_list)); + write_proxies((yyvsp[-1].stmt_list)); + write_client((yyvsp[-1].stmt_list)); + write_server((yyvsp[-1].stmt_list)); + write_regscript((yyvsp[-1].stmt_list)); +#ifndef __REACTOS__ + write_typelib_regscript((yyvsp[-1].stmt_list)); +#endif + write_dlldata((yyvsp[-1].stmt_list)); + write_local_stubs((yyvsp[-1].stmt_list)); } -#line 2581 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 3: -#line 335 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = NULL; } -#line 2587 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 4: -#line 336 "parser.y" /* yacc.c:1646 */ - { push_namespace((yyvsp[-1].str)); } -#line 2593 "parser.tab.c" /* yacc.c:1646 */ +#line 2618 "parser.tab.c" /* yacc.c:1646 */ break; case 5: -#line 337 "parser.y" /* yacc.c:1646 */ - { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); } -#line 2599 "parser.tab.c" /* yacc.c:1646 */ +#line 346 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = NULL; } +#line 2624 "parser.tab.c" /* yacc.c:1646 */ break; case 6: -#line 338 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); } -#line 2605 "parser.tab.c" /* yacc.c:1646 */ +#line 347 "parser.y" /* yacc.c:1646 */ + { push_namespace((yyvsp[-1].str)); } +#line 2630 "parser.tab.c" /* yacc.c:1646 */ break; case 7: -#line 339 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); } -#line 2611 "parser.tab.c" /* yacc.c:1646 */ +#line 348 "parser.y" /* yacc.c:1646 */ + { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); } +#line 2636 "parser.tab.c" /* yacc.c:1646 */ break; case 8: -#line 340 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = (yyvsp[-2].stmt_list); - reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); - } -#line 2619 "parser.tab.c" /* yacc.c:1646 */ +#line 349 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); } +#line 2642 "parser.tab.c" /* yacc.c:1646 */ break; case 9: -#line 343 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); - reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0); - } -#line 2627 "parser.tab.c" /* yacc.c:1646 */ +#line 350 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); } +#line 2648 "parser.tab.c" /* yacc.c:1646 */ break; case 10: -#line 346 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); } -#line 2633 "parser.tab.c" /* yacc.c:1646 */ +#line 351 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = (yyvsp[-2].stmt_list); + reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); + } +#line 2656 "parser.tab.c" /* yacc.c:1646 */ break; case 11: -#line 347 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); } -#line 2639 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 12: -#line 348 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } -#line 2645 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 13: -#line 351 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = NULL; } -#line 2651 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 14: -#line 352 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); } -#line 2657 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 15: -#line 353 "parser.y" /* yacc.c:1646 */ - { push_namespace((yyvsp[-1].str)); } -#line 2663 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 16: #line 354 "parser.y" /* yacc.c:1646 */ - { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); } -#line 2669 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 17: -#line 355 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); } -#line 2675 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 18: -#line 356 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = (yyvsp[-2].stmt_list); reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); } -#line 2681 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 19: -#line 357 "parser.y" /* yacc.c:1646 */ { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0); } -#line 2689 "parser.tab.c" /* yacc.c:1646 */ +#line 2664 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 12: +#line 357 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); } +#line 2670 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 13: +#line 358 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); } +#line 2676 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 14: +#line 359 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } +#line 2682 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 15: +#line 362 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = NULL; } +#line 2688 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 16: +#line 363 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); } +#line 2694 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 17: +#line 364 "parser.y" /* yacc.c:1646 */ + { push_namespace((yyvsp[-1].str)); } +#line 2700 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 18: +#line 365 "parser.y" /* yacc.c:1646 */ + { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); } +#line 2706 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 19: +#line 366 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); } +#line 2712 "parser.tab.c" /* yacc.c:1646 */ break; case 20: -#line 360 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); } -#line 2695 "parser.tab.c" /* yacc.c:1646 */ +#line 367 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = (yyvsp[-2].stmt_list); reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); } +#line 2718 "parser.tab.c" /* yacc.c:1646 */ break; case 21: -#line 361 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } -#line 2701 "parser.tab.c" /* yacc.c:1646 */ +#line 368 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); + reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0); + } +#line 2726 "parser.tab.c" /* yacc.c:1646 */ break; case 22: -#line 362 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_importlib((yyvsp[0].str))); } -#line 2707 "parser.tab.c" /* yacc.c:1646 */ +#line 371 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); } +#line 2732 "parser.tab.c" /* yacc.c:1646 */ break; case 23: -#line 363 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); } -#line 2713 "parser.tab.c" /* yacc.c:1646 */ +#line 372 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } +#line 2738 "parser.tab.c" /* yacc.c:1646 */ break; case 24: -#line 366 "parser.y" /* yacc.c:1646 */ - { (yyval.stmt_list) = NULL; } -#line 2719 "parser.tab.c" /* yacc.c:1646 */ +#line 373 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_importlib((yyvsp[0].str))); } +#line 2744 "parser.tab.c" /* yacc.c:1646 */ break; case 25: -#line 367 "parser.y" /* yacc.c:1646 */ +#line 374 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); } +#line 2750 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 26: +#line 377 "parser.y" /* yacc.c:1646 */ + { (yyval.stmt_list) = NULL; } +#line 2756 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 27: +#line 378 "parser.y" /* yacc.c:1646 */ { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } -#line 2725 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 28: -#line 375 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = make_statement_cppquote((yyvsp[0].str)); } -#line 2731 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 29: -#line 376 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type)); } -#line 2737 "parser.tab.c" /* yacc.c:1646 */ +#line 2762 "parser.tab.c" /* yacc.c:1646 */ break; case 30: -#line 377 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = make_statement_declaration((yyvsp[-1].var)); } -#line 2743 "parser.tab.c" /* yacc.c:1646 */ +#line 386 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = make_statement_cppquote((yyvsp[0].str)); } +#line 2768 "parser.tab.c" /* yacc.c:1646 */ break; case 31: -#line 378 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = make_statement_import((yyvsp[0].str)); } -#line 2749 "parser.tab.c" /* yacc.c:1646 */ +#line 387 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type)); } +#line 2774 "parser.tab.c" /* yacc.c:1646 */ break; case 32: -#line 379 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = (yyvsp[-1].statement); } -#line 2755 "parser.tab.c" /* yacc.c:1646 */ +#line 388 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = make_statement_declaration((yyvsp[-1].var)); } +#line 2780 "parser.tab.c" /* yacc.c:1646 */ break; case 33: -#line 380 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = make_statement_pragma((yyvsp[0].str)); } -#line 2761 "parser.tab.c" /* yacc.c:1646 */ +#line 389 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = make_statement_import((yyvsp[0].str)); } +#line 2786 "parser.tab.c" /* yacc.c:1646 */ break; case 34: -#line 381 "parser.y" /* yacc.c:1646 */ - { (yyval.statement) = NULL; } -#line 2767 "parser.tab.c" /* yacc.c:1646 */ +#line 390 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = (yyvsp[-1].statement); } +#line 2792 "parser.tab.c" /* yacc.c:1646 */ break; case 35: -#line 385 "parser.y" /* yacc.c:1646 */ +#line 391 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = make_statement_pragma((yyvsp[0].str)); } +#line 2798 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 36: +#line 392 "parser.y" /* yacc.c:1646 */ + { (yyval.statement) = NULL; } +#line 2804 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 37: +#line 396 "parser.y" /* yacc.c:1646 */ { int result; (yyval.statement) = NULL; @@ -2775,912 +2812,916 @@ yyreduce: if(!result) error_loc("expected \"disable\" or \"enable\"\n"); } -#line 2779 "parser.tab.c" /* yacc.c:1646 */ +#line 2816 "parser.tab.c" /* yacc.c:1646 */ break; - case 36: -#line 395 "parser.y" /* yacc.c:1646 */ + case 38: +#line 406 "parser.y" /* yacc.c:1646 */ { (yyval.warning_list) = append_warning(NULL, (yyvsp[0].num)); } -#line 2785 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 37: -#line 396 "parser.y" /* yacc.c:1646 */ - { (yyval.warning_list) = append_warning((yyvsp[-1].warning_list), (yyvsp[0].num)); } -#line 2791 "parser.tab.c" /* yacc.c:1646 */ +#line 2822 "parser.tab.c" /* yacc.c:1646 */ break; case 39: -#line 401 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); } -#line 2797 "parser.tab.c" /* yacc.c:1646 */ +#line 407 "parser.y" /* yacc.c:1646 */ + { (yyval.warning_list) = append_warning((yyvsp[-1].warning_list), (yyvsp[0].num)); } +#line 2828 "parser.tab.c" /* yacc.c:1646 */ break; case 41: -#line 403 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); } -#line 2803 "parser.tab.c" /* yacc.c:1646 */ +#line 412 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); } +#line 2834 "parser.tab.c" /* yacc.c:1646 */ break; case 43: -#line 405 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); } -#line 2809 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 44: -#line 406 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[-1].attr_list)); } -#line 2815 "parser.tab.c" /* yacc.c:1646 */ +#line 414 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); } +#line 2840 "parser.tab.c" /* yacc.c:1646 */ break; case 45: -#line 407 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[-1].attr_list)); } -#line 2821 "parser.tab.c" /* yacc.c:1646 */ +#line 416 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); } +#line 2846 "parser.tab.c" /* yacc.c:1646 */ break; case 46: -#line 408 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_union_attrs((yyvsp[-1].attr_list)); } -#line 2827 "parser.tab.c" /* yacc.c:1646 */ +#line 417 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[-1].attr_list)); } +#line 2852 "parser.tab.c" /* yacc.c:1646 */ break; case 47: -#line 411 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[-1].str); } -#line 2833 "parser.tab.c" /* yacc.c:1646 */ +#line 418 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[-1].attr_list)); } +#line 2858 "parser.tab.c" /* yacc.c:1646 */ break; case 48: -#line 413 "parser.y" /* yacc.c:1646 */ +#line 419 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_union_attrs((yyvsp[-1].attr_list)); } +#line 2864 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 49: +#line 422 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[-1].str); } +#line 2870 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 50: +#line 424 "parser.y" /* yacc.c:1646 */ { assert(yychar == YYEMPTY); (yyval.import) = xmalloc(sizeof(struct _import_t)); (yyval.import)->name = (yyvsp[-1].str); (yyval.import)->import_performed = do_import((yyvsp[-1].str)); if (!(yyval.import)->import_performed) yychar = aEOF; } -#line 2844 "parser.tab.c" /* yacc.c:1646 */ +#line 2881 "parser.tab.c" /* yacc.c:1646 */ break; - case 49: -#line 421 "parser.y" /* yacc.c:1646 */ + case 51: +#line 432 "parser.y" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[-2].import)->name; if ((yyvsp[-2].import)->import_performed) pop_import(); free((yyvsp[-2].import)); } -#line 2853 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 50: -#line 428 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[-2].str); if(!parse_only) add_importlib((yyvsp[-2].str)); } -#line 2859 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 51: -#line 431 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[0].str); } -#line 2865 "parser.tab.c" /* yacc.c:1646 */ +#line 2890 "parser.tab.c" /* yacc.c:1646 */ break; case 52: -#line 432 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[0].str); } -#line 2871 "parser.tab.c" /* yacc.c:1646 */ +#line 440 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[-2].str); if(!parse_only) add_importlib((yyvsp[-2].str)); } +#line 2896 "parser.tab.c" /* yacc.c:1646 */ break; case 53: -#line 434 "parser.y" /* yacc.c:1646 */ - { (yyval.typelib) = make_library((yyvsp[-1].str), check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list))); - if (!parse_only) start_typelib((yyval.typelib)); - } -#line 2879 "parser.tab.c" /* yacc.c:1646 */ +#line 446 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[0].str); } +#line 2902 "parser.tab.c" /* yacc.c:1646 */ break; case 54: -#line 439 "parser.y" /* yacc.c:1646 */ +#line 447 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[0].str); } +#line 2908 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 55: +#line 449 "parser.y" /* yacc.c:1646 */ + { (yyval.typelib) = make_library((yyvsp[-1].str), check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list))); +/* ifdef __REACTOS__ */ + if (!parse_only) start_typelib((yyval.typelib)); +/* else + if (!parse_only && do_typelib) current_typelib = $$; +*/ + } +#line 2920 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 56: +#line 459 "parser.y" /* yacc.c:1646 */ { (yyval.typelib) = (yyvsp[-3].typelib); (yyval.typelib)->stmts = (yyvsp[-2].stmt_list); if (!parse_only) end_typelib(); } -#line 2888 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 55: -#line 445 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = NULL; } -#line 2894 "parser.tab.c" /* yacc.c:1646 */ +#line 2929 "parser.tab.c" /* yacc.c:1646 */ break; case 57: -#line 449 "parser.y" /* yacc.c:1646 */ - { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); } -#line 2900 "parser.tab.c" /* yacc.c:1646 */ +#line 468 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = NULL; } +#line 2935 "parser.tab.c" /* yacc.c:1646 */ break; - case 58: -#line 450 "parser.y" /* yacc.c:1646 */ - { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) ); } -#line 2906 "parser.tab.c" /* yacc.c:1646 */ + case 59: +#line 472 "parser.y" /* yacc.c:1646 */ + { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); } +#line 2941 "parser.tab.c" /* yacc.c:1646 */ break; case 60: -#line 454 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = append_var( (yyvsp[-2].var_list), make_var(strdup("...")) ); } -#line 2912 "parser.tab.c" /* yacc.c:1646 */ +#line 473 "parser.y" /* yacc.c:1646 */ + { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) ); } +#line 2947 "parser.tab.c" /* yacc.c:1646 */ break; - case 61: -#line 458 "parser.y" /* yacc.c:1646 */ + case 62: +#line 477 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = append_var( (yyvsp[-2].var_list), make_var(strdup("...")) ); } +#line 2953 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 63: +#line 481 "parser.y" /* yacc.c:1646 */ { if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER) error_loc("invalid storage class for function parameter\n"); (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE); free((yyvsp[-1].declspec)); free((yyvsp[0].declarator)); } -#line 2922 "parser.tab.c" /* yacc.c:1646 */ +#line 2963 "parser.tab.c" /* yacc.c:1646 */ break; - case 62: -#line 463 "parser.y" /* yacc.c:1646 */ + case 64: +#line 486 "parser.y" /* yacc.c:1646 */ { if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER) error_loc("invalid storage class for function parameter\n"); (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE); free((yyvsp[-1].declspec)); free((yyvsp[0].declarator)); } -#line 2932 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 63: -#line 470 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = (yyvsp[-1].expr); - if (!(yyval.expr)->is_const) - error_loc("array dimension is not an integer constant\n"); - } -#line 2941 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 64: -#line 474 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr(EXPR_VOID); } -#line 2947 "parser.tab.c" /* yacc.c:1646 */ +#line 2973 "parser.tab.c" /* yacc.c:1646 */ break; case 65: -#line 475 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr(EXPR_VOID); } -#line 2953 "parser.tab.c" /* yacc.c:1646 */ +#line 493 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = (yyvsp[-1].expr); + if (!(yyval.expr)->is_const || (yyval.expr)->cval <= 0) + error_loc("array dimension is not a positive integer constant\n"); + } +#line 2982 "parser.tab.c" /* yacc.c:1646 */ break; case 66: -#line 478 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = NULL; } -#line 2959 "parser.tab.c" /* yacc.c:1646 */ +#line 497 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr(EXPR_VOID); } +#line 2988 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 67: +#line 498 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr(EXPR_VOID); } +#line 2994 "parser.tab.c" /* yacc.c:1646 */ break; case 68: -#line 483 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = (yyvsp[-1].attr_list); } -#line 2965 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 69: -#line 486 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); } -#line 2971 "parser.tab.c" /* yacc.c:1646 */ +#line 501 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = NULL; } +#line 3000 "parser.tab.c" /* yacc.c:1646 */ break; case 70: -#line 487 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); } -#line 2977 "parser.tab.c" /* yacc.c:1646 */ +#line 506 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = (yyvsp[-1].attr_list); } +#line 3006 "parser.tab.c" /* yacc.c:1646 */ break; case 71: -#line 488 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); } -#line 2983 "parser.tab.c" /* yacc.c:1646 */ +#line 509 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); } +#line 3012 "parser.tab.c" /* yacc.c:1646 */ break; case 72: -#line 491 "parser.y" /* yacc.c:1646 */ - { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); } -#line 2989 "parser.tab.c" /* yacc.c:1646 */ +#line 510 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); } +#line 3018 "parser.tab.c" /* yacc.c:1646 */ break; case 73: -#line 492 "parser.y" /* yacc.c:1646 */ - { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); } -#line 2995 "parser.tab.c" /* yacc.c:1646 */ +#line 511 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); } +#line 3024 "parser.tab.c" /* yacc.c:1646 */ break; case 74: -#line 495 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = NULL; } -#line 3001 "parser.tab.c" /* yacc.c:1646 */ +#line 514 "parser.y" /* yacc.c:1646 */ + { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); } +#line 3030 "parser.tab.c" /* yacc.c:1646 */ break; case 75: -#line 496 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); } -#line 3007 "parser.tab.c" /* yacc.c:1646 */ +#line 515 "parser.y" /* yacc.c:1646 */ + { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); } +#line 3036 "parser.tab.c" /* yacc.c:1646 */ break; case 76: -#line 497 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[-1].str)); } -#line 3013 "parser.tab.c" /* yacc.c:1646 */ +#line 518 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = NULL; } +#line 3042 "parser.tab.c" /* yacc.c:1646 */ break; case 77: -#line 498 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_APPOBJECT); } -#line 3019 "parser.tab.c" /* yacc.c:1646 */ +#line 519 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); } +#line 3048 "parser.tab.c" /* yacc.c:1646 */ break; case 78: -#line 499 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_ASYNC); } -#line 3025 "parser.tab.c" /* yacc.c:1646 */ +#line 520 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[-1].str)); } +#line 3054 "parser.tab.c" /* yacc.c:1646 */ break; case 79: -#line 500 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); } -#line 3031 "parser.tab.c" /* yacc.c:1646 */ +#line 521 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_APPOBJECT); } +#line 3060 "parser.tab.c" /* yacc.c:1646 */ break; case 80: -#line 501 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_BINDABLE); } -#line 3037 "parser.tab.c" /* yacc.c:1646 */ +#line 522 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_ASYNC); } +#line 3066 "parser.tab.c" /* yacc.c:1646 */ break; case 81: -#line 502 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_BROADCAST); } -#line 3043 "parser.tab.c" /* yacc.c:1646 */ +#line 523 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); } +#line 3072 "parser.tab.c" /* yacc.c:1646 */ break; case 82: -#line 503 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); } -#line 3049 "parser.tab.c" /* yacc.c:1646 */ +#line 524 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_BINDABLE); } +#line 3078 "parser.tab.c" /* yacc.c:1646 */ break; case 83: -#line 504 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); } -#line 3055 "parser.tab.c" /* yacc.c:1646 */ +#line 525 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_BROADCAST); } +#line 3084 "parser.tab.c" /* yacc.c:1646 */ break; case 84: -#line 505 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_CODE); } -#line 3061 "parser.tab.c" /* yacc.c:1646 */ +#line 526 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); } +#line 3090 "parser.tab.c" /* yacc.c:1646 */ break; case 85: -#line 506 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_COMMSTATUS); } -#line 3067 "parser.tab.c" /* yacc.c:1646 */ +#line 527 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); } +#line 3096 "parser.tab.c" /* yacc.c:1646 */ break; case 86: -#line 507 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); } -#line 3073 "parser.tab.c" /* yacc.c:1646 */ +#line 528 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_CODE); } +#line 3102 "parser.tab.c" /* yacc.c:1646 */ break; case 87: -#line 508 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ } -#line 3079 "parser.tab.c" /* yacc.c:1646 */ +#line 529 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_COMMSTATUS); } +#line 3108 "parser.tab.c" /* yacc.c:1646 */ break; case 88: -#line 509 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ } -#line 3085 "parser.tab.c" /* yacc.c:1646 */ +#line 530 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); } +#line 3114 "parser.tab.c" /* yacc.c:1646 */ break; case 89: -#line 510 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_CONTROL); } -#line 3091 "parser.tab.c" /* yacc.c:1646 */ +#line 531 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ } +#line 3120 "parser.tab.c" /* yacc.c:1646 */ break; case 90: -#line 511 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DECODE); } -#line 3097 "parser.tab.c" /* yacc.c:1646 */ +#line 532 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ } +#line 3126 "parser.tab.c" /* yacc.c:1646 */ break; case 91: -#line 512 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DEFAULT); } -#line 3103 "parser.tab.c" /* yacc.c:1646 */ +#line 533 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_CONTROL); } +#line 3132 "parser.tab.c" /* yacc.c:1646 */ break; case 92: -#line 513 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DEFAULTBIND); } -#line 3109 "parser.tab.c" /* yacc.c:1646 */ +#line 534 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DECODE); } +#line 3138 "parser.tab.c" /* yacc.c:1646 */ break; case 93: -#line 514 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); } -#line 3115 "parser.tab.c" /* yacc.c:1646 */ +#line 535 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DEFAULT); } +#line 3144 "parser.tab.c" /* yacc.c:1646 */ break; case 94: -#line 515 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[-1].expr)); } -#line 3121 "parser.tab.c" /* yacc.c:1646 */ +#line 536 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DEFAULTBIND); } +#line 3150 "parser.tab.c" /* yacc.c:1646 */ break; case 95: -#line 516 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); } -#line 3127 "parser.tab.c" /* yacc.c:1646 */ +#line 537 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); } +#line 3156 "parser.tab.c" /* yacc.c:1646 */ break; case 96: -#line 517 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DISABLECONSISTENCYCHECK); } -#line 3133 "parser.tab.c" /* yacc.c:1646 */ +#line 538 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[-1].expr)); } +#line 3162 "parser.tab.c" /* yacc.c:1646 */ break; case 97: -#line 518 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); } -#line 3139 "parser.tab.c" /* yacc.c:1646 */ +#line 539 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); } +#line 3168 "parser.tab.c" /* yacc.c:1646 */ break; case 98: -#line 519 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); } -#line 3145 "parser.tab.c" /* yacc.c:1646 */ +#line 540 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DISABLECONSISTENCYCHECK); } +#line 3174 "parser.tab.c" /* yacc.c:1646 */ break; case 99: -#line 520 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_DUAL); } -#line 3151 "parser.tab.c" /* yacc.c:1646 */ +#line 541 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); } +#line 3180 "parser.tab.c" /* yacc.c:1646 */ break; case 100: -#line 521 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_ENABLEALLOCATE); } -#line 3157 "parser.tab.c" /* yacc.c:1646 */ +#line 542 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); } +#line 3186 "parser.tab.c" /* yacc.c:1646 */ break; case 101: -#line 522 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_ENCODE); } -#line 3163 "parser.tab.c" /* yacc.c:1646 */ +#line 543 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DUAL); } +#line 3192 "parser.tab.c" /* yacc.c:1646 */ break; case 102: -#line 523 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); } -#line 3169 "parser.tab.c" /* yacc.c:1646 */ +#line 544 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_ENABLEALLOCATE); } +#line 3198 "parser.tab.c" /* yacc.c:1646 */ break; case 103: -#line 524 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[-1].expr)); } -#line 3175 "parser.tab.c" /* yacc.c:1646 */ +#line 545 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_ENCODE); } +#line 3204 "parser.tab.c" /* yacc.c:1646 */ break; case 104: -#line 525 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); } -#line 3181 "parser.tab.c" /* yacc.c:1646 */ +#line 546 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); } +#line 3210 "parser.tab.c" /* yacc.c:1646 */ break; case 105: -#line 526 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_FAULTSTATUS); } -#line 3187 "parser.tab.c" /* yacc.c:1646 */ +#line 547 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[-1].expr)); } +#line 3216 "parser.tab.c" /* yacc.c:1646 */ break; case 106: -#line 527 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_FORCEALLOCATE); } -#line 3193 "parser.tab.c" /* yacc.c:1646 */ +#line 548 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); } +#line 3222 "parser.tab.c" /* yacc.c:1646 */ break; case 107: -#line 528 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_HANDLE); } -#line 3199 "parser.tab.c" /* yacc.c:1646 */ +#line 549 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_FAULTSTATUS); } +#line 3228 "parser.tab.c" /* yacc.c:1646 */ break; case 108: -#line 529 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); } -#line 3205 "parser.tab.c" /* yacc.c:1646 */ +#line 550 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_FORCEALLOCATE); } +#line 3234 "parser.tab.c" /* yacc.c:1646 */ break; case 109: -#line 530 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-1].str)); } -#line 3211 "parser.tab.c" /* yacc.c:1646 */ +#line 551 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_HANDLE); } +#line 3240 "parser.tab.c" /* yacc.c:1646 */ break; case 110: -#line 531 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[-1].str)); } -#line 3217 "parser.tab.c" /* yacc.c:1646 */ +#line 552 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); } +#line 3246 "parser.tab.c" /* yacc.c:1646 */ break; case 111: -#line 532 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[-1].expr)); } -#line 3223 "parser.tab.c" /* yacc.c:1646 */ +#line 553 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-1].str)); } +#line 3252 "parser.tab.c" /* yacc.c:1646 */ break; case 112: -#line 533 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[-1].str)); } -#line 3229 "parser.tab.c" /* yacc.c:1646 */ +#line 554 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[-1].str)); } +#line 3258 "parser.tab.c" /* yacc.c:1646 */ break; case 113: -#line 534 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_HIDDEN); } -#line 3235 "parser.tab.c" /* yacc.c:1646 */ +#line 555 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[-1].expr)); } +#line 3264 "parser.tab.c" /* yacc.c:1646 */ break; case 114: -#line 535 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[-1].expr)); } -#line 3241 "parser.tab.c" /* yacc.c:1646 */ +#line 556 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[-1].str)); } +#line 3270 "parser.tab.c" /* yacc.c:1646 */ break; case 115: -#line 536 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); } -#line 3247 "parser.tab.c" /* yacc.c:1646 */ +#line 557 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_HIDDEN); } +#line 3276 "parser.tab.c" /* yacc.c:1646 */ break; case 116: -#line 537 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_IGNORE); } -#line 3253 "parser.tab.c" /* yacc.c:1646 */ +#line 558 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[-1].expr)); } +#line 3282 "parser.tab.c" /* yacc.c:1646 */ break; case 117: -#line 538 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[-1].expr)); } -#line 3259 "parser.tab.c" /* yacc.c:1646 */ +#line 559 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); } +#line 3288 "parser.tab.c" /* yacc.c:1646 */ break; case 118: -#line 539 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); } -#line 3265 "parser.tab.c" /* yacc.c:1646 */ +#line 560 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_IGNORE); } +#line 3294 "parser.tab.c" /* yacc.c:1646 */ break; case 119: -#line 540 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[-1].var)); } -#line 3271 "parser.tab.c" /* yacc.c:1646 */ +#line 561 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[-1].expr)); } +#line 3300 "parser.tab.c" /* yacc.c:1646 */ break; case 120: -#line 541 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_IN); } -#line 3277 "parser.tab.c" /* yacc.c:1646 */ +#line 562 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); } +#line 3306 "parser.tab.c" /* yacc.c:1646 */ break; case 121: -#line 542 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_INPUTSYNC); } -#line 3283 "parser.tab.c" /* yacc.c:1646 */ +#line 563 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[-1].var)); } +#line 3312 "parser.tab.c" /* yacc.c:1646 */ break; case 122: -#line 543 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[-1].expr_list)); } -#line 3289 "parser.tab.c" /* yacc.c:1646 */ +#line 564 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_IN); } +#line 3318 "parser.tab.c" /* yacc.c:1646 */ break; case 123: -#line 544 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[-1].expr)); } -#line 3295 "parser.tab.c" /* yacc.c:1646 */ +#line 565 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_INPUTSYNC); } +#line 3324 "parser.tab.c" /* yacc.c:1646 */ break; case 124: -#line 545 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PARAMLCID); } -#line 3301 "parser.tab.c" /* yacc.c:1646 */ +#line 566 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[-1].expr_list)); } +#line 3330 "parser.tab.c" /* yacc.c:1646 */ break; case 125: -#line 546 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_LICENSED); } -#line 3307 "parser.tab.c" /* yacc.c:1646 */ +#line 567 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[-1].expr)); } +#line 3336 "parser.tab.c" /* yacc.c:1646 */ break; case 126: -#line 547 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_LOCAL); } -#line 3313 "parser.tab.c" /* yacc.c:1646 */ +#line 568 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PARAMLCID); } +#line 3342 "parser.tab.c" /* yacc.c:1646 */ break; case 127: -#line 548 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_MAYBE); } -#line 3319 "parser.tab.c" /* yacc.c:1646 */ +#line 569 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_LICENSED); } +#line 3348 "parser.tab.c" /* yacc.c:1646 */ break; case 128: -#line 549 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_MESSAGE); } -#line 3325 "parser.tab.c" /* yacc.c:1646 */ +#line 570 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_LOCAL); } +#line 3354 "parser.tab.c" /* yacc.c:1646 */ break; case 129: -#line 550 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_NOCODE); } -#line 3331 "parser.tab.c" /* yacc.c:1646 */ +#line 571 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_MAYBE); } +#line 3360 "parser.tab.c" /* yacc.c:1646 */ break; case 130: -#line 551 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); } -#line 3337 "parser.tab.c" /* yacc.c:1646 */ +#line 572 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_MESSAGE); } +#line 3366 "parser.tab.c" /* yacc.c:1646 */ break; case 131: -#line 552 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_NONCREATABLE); } -#line 3343 "parser.tab.c" /* yacc.c:1646 */ +#line 573 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_NOCODE); } +#line 3372 "parser.tab.c" /* yacc.c:1646 */ break; case 132: -#line 553 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); } -#line 3349 "parser.tab.c" /* yacc.c:1646 */ +#line 574 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); } +#line 3378 "parser.tab.c" /* yacc.c:1646 */ break; case 133: -#line 554 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_NOTIFY); } -#line 3355 "parser.tab.c" /* yacc.c:1646 */ +#line 575 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_NONCREATABLE); } +#line 3384 "parser.tab.c" /* yacc.c:1646 */ break; case 134: -#line 555 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_NOTIFYFLAG); } -#line 3361 "parser.tab.c" /* yacc.c:1646 */ +#line 576 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); } +#line 3390 "parser.tab.c" /* yacc.c:1646 */ break; case 135: -#line 556 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_OBJECT); } -#line 3367 "parser.tab.c" /* yacc.c:1646 */ +#line 577 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_NOTIFY); } +#line 3396 "parser.tab.c" /* yacc.c:1646 */ break; case 136: -#line 557 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_ODL); } -#line 3373 "parser.tab.c" /* yacc.c:1646 */ +#line 578 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_NOTIFYFLAG); } +#line 3402 "parser.tab.c" /* yacc.c:1646 */ break; case 137: -#line 558 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); } -#line 3379 "parser.tab.c" /* yacc.c:1646 */ +#line 579 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_OBJECT); } +#line 3408 "parser.tab.c" /* yacc.c:1646 */ break; case 138: -#line 559 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_OPTIMIZE, (yyvsp[-1].str)); } -#line 3385 "parser.tab.c" /* yacc.c:1646 */ +#line 580 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_ODL); } +#line 3414 "parser.tab.c" /* yacc.c:1646 */ break; case 139: -#line 560 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_OPTIONAL); } -#line 3391 "parser.tab.c" /* yacc.c:1646 */ +#line 581 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); } +#line 3420 "parser.tab.c" /* yacc.c:1646 */ break; case 140: -#line 561 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_OUT); } -#line 3397 "parser.tab.c" /* yacc.c:1646 */ +#line 582 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_OPTIMIZE, (yyvsp[-1].str)); } +#line 3426 "parser.tab.c" /* yacc.c:1646 */ break; case 141: -#line 562 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PARTIALIGNORE); } -#line 3403 "parser.tab.c" /* yacc.c:1646 */ +#line 583 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_OPTIONAL); } +#line 3432 "parser.tab.c" /* yacc.c:1646 */ break; case 142: -#line 563 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[-1].num)); } -#line 3409 "parser.tab.c" /* yacc.c:1646 */ +#line 584 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_OUT); } +#line 3438 "parser.tab.c" /* yacc.c:1646 */ break; case 143: -#line 564 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_PROGID, (yyvsp[-1].str)); } -#line 3415 "parser.tab.c" /* yacc.c:1646 */ +#line 585 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PARTIALIGNORE); } +#line 3444 "parser.tab.c" /* yacc.c:1646 */ break; case 144: -#line 565 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PROPGET); } -#line 3421 "parser.tab.c" /* yacc.c:1646 */ +#line 586 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[-1].num)); } +#line 3450 "parser.tab.c" /* yacc.c:1646 */ break; case 145: -#line 566 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PROPPUT); } -#line 3427 "parser.tab.c" /* yacc.c:1646 */ +#line 587 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_PROGID, (yyvsp[-1].str)); } +#line 3456 "parser.tab.c" /* yacc.c:1646 */ break; case 146: -#line 567 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PROPPUTREF); } -#line 3433 "parser.tab.c" /* yacc.c:1646 */ +#line 588 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PROPGET); } +#line 3462 "parser.tab.c" /* yacc.c:1646 */ break; case 147: -#line 568 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PROXY); } -#line 3439 "parser.tab.c" /* yacc.c:1646 */ +#line 589 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PROPPUT); } +#line 3468 "parser.tab.c" /* yacc.c:1646 */ break; case 148: -#line 569 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_PUBLIC); } -#line 3445 "parser.tab.c" /* yacc.c:1646 */ +#line 590 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PROPPUTREF); } +#line 3474 "parser.tab.c" /* yacc.c:1646 */ break; case 149: -#line 571 "parser.y" /* yacc.c:1646 */ - { expr_list_t *list = append_expr( NULL, (yyvsp[-3].expr) ); - list = append_expr( list, (yyvsp[-1].expr) ); - (yyval.attr) = make_attrp(ATTR_RANGE, list); } -#line 3453 "parser.tab.c" /* yacc.c:1646 */ +#line 591 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PROXY); } +#line 3480 "parser.tab.c" /* yacc.c:1646 */ break; case 150: -#line 574 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_READONLY); } -#line 3459 "parser.tab.c" /* yacc.c:1646 */ +#line 592 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_PUBLIC); } +#line 3486 "parser.tab.c" /* yacc.c:1646 */ break; case 151: -#line 575 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_REPRESENTAS, (yyvsp[-1].type)); } -#line 3465 "parser.tab.c" /* yacc.c:1646 */ +#line 594 "parser.y" /* yacc.c:1646 */ + { expr_list_t *list = append_expr( NULL, (yyvsp[-3].expr) ); + list = append_expr( list, (yyvsp[-1].expr) ); + (yyval.attr) = make_attrp(ATTR_RANGE, list); } +#line 3494 "parser.tab.c" /* yacc.c:1646 */ break; case 152: -#line 576 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); } -#line 3471 "parser.tab.c" /* yacc.c:1646 */ +#line 597 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_READONLY); } +#line 3500 "parser.tab.c" /* yacc.c:1646 */ break; case 153: -#line 577 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_RESTRICTED); } -#line 3477 "parser.tab.c" /* yacc.c:1646 */ +#line 598 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_REPRESENTAS, (yyvsp[-1].type)); } +#line 3506 "parser.tab.c" /* yacc.c:1646 */ break; case 154: -#line 578 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_RETVAL); } -#line 3483 "parser.tab.c" /* yacc.c:1646 */ +#line 599 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); } +#line 3512 "parser.tab.c" /* yacc.c:1646 */ break; case 155: -#line 579 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[-1].expr_list)); } -#line 3489 "parser.tab.c" /* yacc.c:1646 */ +#line 600 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_RESTRICTED); } +#line 3518 "parser.tab.c" /* yacc.c:1646 */ break; case 156: -#line 580 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_SOURCE); } -#line 3495 "parser.tab.c" /* yacc.c:1646 */ +#line 601 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_RETVAL); } +#line 3524 "parser.tab.c" /* yacc.c:1646 */ break; case 157: -#line 581 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); } -#line 3501 "parser.tab.c" /* yacc.c:1646 */ +#line 602 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[-1].expr_list)); } +#line 3530 "parser.tab.c" /* yacc.c:1646 */ break; case 158: -#line 582 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_STRING); } -#line 3507 "parser.tab.c" /* yacc.c:1646 */ +#line 603 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_SOURCE); } +#line 3536 "parser.tab.c" /* yacc.c:1646 */ break; case 159: -#line 583 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[-1].expr)); } -#line 3513 "parser.tab.c" /* yacc.c:1646 */ +#line 604 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); } +#line 3542 "parser.tab.c" /* yacc.c:1646 */ break; case 160: -#line 584 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[-1].type)); } -#line 3519 "parser.tab.c" /* yacc.c:1646 */ +#line 605 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_STRING); } +#line 3548 "parser.tab.c" /* yacc.c:1646 */ break; case 161: -#line 585 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[-1].type)); } -#line 3525 "parser.tab.c" /* yacc.c:1646 */ +#line 606 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[-1].expr)); } +#line 3554 "parser.tab.c" /* yacc.c:1646 */ break; case 162: -#line 586 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_THREADING, (yyvsp[-1].num)); } -#line 3531 "parser.tab.c" /* yacc.c:1646 */ +#line 607 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[-1].type)); } +#line 3560 "parser.tab.c" /* yacc.c:1646 */ break; case 163: -#line 587 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_UIDEFAULT); } -#line 3537 "parser.tab.c" /* yacc.c:1646 */ +#line 608 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[-1].type)); } +#line 3566 "parser.tab.c" /* yacc.c:1646 */ break; case 164: -#line 588 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_USESGETLASTERROR); } -#line 3543 "parser.tab.c" /* yacc.c:1646 */ +#line 609 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_THREADING, (yyvsp[-1].num)); } +#line 3572 "parser.tab.c" /* yacc.c:1646 */ break; case 165: -#line 589 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_USERMARSHAL, (yyvsp[-1].type)); } -#line 3549 "parser.tab.c" /* yacc.c:1646 */ +#line 610 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_UIDEFAULT); } +#line 3578 "parser.tab.c" /* yacc.c:1646 */ break; case 166: -#line 590 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[-1].uuid)); } -#line 3555 "parser.tab.c" /* yacc.c:1646 */ +#line 611 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_USESGETLASTERROR); } +#line 3584 "parser.tab.c" /* yacc.c:1646 */ break; case 167: -#line 591 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_ASYNCUUID, (yyvsp[-1].uuid)); } -#line 3561 "parser.tab.c" /* yacc.c:1646 */ +#line 612 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_USERMARSHAL, (yyvsp[-1].type)); } +#line 3590 "parser.tab.c" /* yacc.c:1646 */ break; case 168: -#line 592 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_V1ENUM); } -#line 3567 "parser.tab.c" /* yacc.c:1646 */ +#line 613 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[-1].uuid)); } +#line 3596 "parser.tab.c" /* yacc.c:1646 */ break; case 169: -#line 593 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_VARARG); } -#line 3573 "parser.tab.c" /* yacc.c:1646 */ +#line 614 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_ASYNCUUID, (yyvsp[-1].uuid)); } +#line 3602 "parser.tab.c" /* yacc.c:1646 */ break; case 170: -#line 594 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[-1].num)); } -#line 3579 "parser.tab.c" /* yacc.c:1646 */ +#line 615 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_V1ENUM); } +#line 3608 "parser.tab.c" /* yacc.c:1646 */ break; case 171: -#line 595 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_VIPROGID, (yyvsp[-1].str)); } -#line 3585 "parser.tab.c" /* yacc.c:1646 */ +#line 616 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_VARARG); } +#line 3614 "parser.tab.c" /* yacc.c:1646 */ break; case 172: -#line 596 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[-1].type)); } -#line 3591 "parser.tab.c" /* yacc.c:1646 */ +#line 617 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[-1].num)); } +#line 3620 "parser.tab.c" /* yacc.c:1646 */ break; case 173: -#line 597 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[0].num)); } -#line 3597 "parser.tab.c" /* yacc.c:1646 */ +#line 618 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_VIPROGID, (yyvsp[-1].str)); } +#line 3626 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 174: +#line 619 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[-1].type)); } +#line 3632 "parser.tab.c" /* yacc.c:1646 */ break; case 175: -#line 602 "parser.y" /* yacc.c:1646 */ - { if (!is_valid_uuid((yyvsp[0].str))) - error_loc("invalid UUID: %s\n", (yyvsp[0].str)); - (yyval.uuid) = parse_uuid((yyvsp[0].str)); } -#line 3605 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 176: -#line 607 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = xstrdup("__cdecl"); } -#line 3611 "parser.tab.c" /* yacc.c:1646 */ +#line 620 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[0].num)); } +#line 3638 "parser.tab.c" /* yacc.c:1646 */ break; case 177: -#line 608 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = xstrdup("__fastcall"); } -#line 3617 "parser.tab.c" /* yacc.c:1646 */ +#line 625 "parser.y" /* yacc.c:1646 */ + { if (!is_valid_uuid((yyvsp[0].str))) + error_loc("invalid UUID: %s\n", (yyvsp[0].str)); + (yyval.uuid) = parse_uuid((yyvsp[0].str)); } +#line 3646 "parser.tab.c" /* yacc.c:1646 */ break; case 178: -#line 609 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = xstrdup("__pascal"); } -#line 3623 "parser.tab.c" /* yacc.c:1646 */ +#line 630 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = xstrdup("__cdecl"); } +#line 3652 "parser.tab.c" /* yacc.c:1646 */ break; case 179: -#line 610 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = xstrdup("__stdcall"); } -#line 3629 "parser.tab.c" /* yacc.c:1646 */ +#line 631 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = xstrdup("__fastcall"); } +#line 3658 "parser.tab.c" /* yacc.c:1646 */ break; case 180: -#line 613 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = NULL; } -#line 3635 "parser.tab.c" /* yacc.c:1646 */ +#line 632 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = xstrdup("__pascal"); } +#line 3664 "parser.tab.c" /* yacc.c:1646 */ break; case 181: -#line 614 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); } -#line 3641 "parser.tab.c" /* yacc.c:1646 */ +#line 633 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = xstrdup("__stdcall"); } +#line 3670 "parser.tab.c" /* yacc.c:1646 */ break; case 182: -#line 617 "parser.y" /* yacc.c:1646 */ +#line 636 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = NULL; } +#line 3676 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 183: +#line 637 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); } +#line 3682 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 184: +#line 640 "parser.y" /* yacc.c:1646 */ { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, (yyvsp[-2].expr) )); (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL); (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a ); } -#line 3650 "parser.tab.c" /* yacc.c:1646 */ +#line 3691 "parser.tab.c" /* yacc.c:1646 */ break; - case 183: -#line 621 "parser.y" /* yacc.c:1646 */ + case 185: +#line 644 "parser.y" /* yacc.c:1646 */ { attr_t *a = make_attr(ATTR_DEFAULT); (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL); (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a ); } -#line 3659 "parser.tab.c" /* yacc.c:1646 */ +#line 3700 "parser.tab.c" /* yacc.c:1646 */ break; - case 184: -#line 627 "parser.y" /* yacc.c:1646 */ + case 186: +#line 650 "parser.y" /* yacc.c:1646 */ { (yyval.var_list) = NULL; } -#line 3665 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 185: -#line 628 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = (yyvsp[-1].var_list); } -#line 3671 "parser.tab.c" /* yacc.c:1646 */ +#line 3706 "parser.tab.c" /* yacc.c:1646 */ break; case 187: -#line 632 "parser.y" /* yacc.c:1646 */ +#line 651 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = (yyvsp[-1].var_list); } +#line 3712 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 189: +#line 655 "parser.y" /* yacc.c:1646 */ { if (!(yyvsp[0].var)->eval) (yyvsp[0].var)->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); } -#line 3680 "parser.tab.c" /* yacc.c:1646 */ +#line 3721 "parser.tab.c" /* yacc.c:1646 */ break; - case 188: -#line 636 "parser.y" /* yacc.c:1646 */ + case 190: +#line 659 "parser.y" /* yacc.c:1646 */ { if (!(yyvsp[0].var)->eval) { var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry ); @@ -3691,650 +3732,656 @@ yyreduce: } (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) ); } -#line 3695 "parser.tab.c" /* yacc.c:1646 */ +#line 3736 "parser.tab.c" /* yacc.c:1646 */ break; - case 189: -#line 648 "parser.y" /* yacc.c:1646 */ + case 191: +#line 671 "parser.y" /* yacc.c:1646 */ { (yyval.var) = reg_const((yyvsp[-2].var)); (yyval.var)->eval = (yyvsp[0].expr); (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0); } -#line 3704 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 190: -#line 652 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = reg_const((yyvsp[0].var)); - (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0); - } -#line 3712 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 191: -#line 657 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_enum((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); } -#line 3718 "parser.tab.c" /* yacc.c:1646 */ +#line 3745 "parser.tab.c" /* yacc.c:1646 */ break; case 192: -#line 660 "parser.y" /* yacc.c:1646 */ - { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); } -#line 3724 "parser.tab.c" /* yacc.c:1646 */ +#line 675 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = reg_const((yyvsp[0].var)); + (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0); + } +#line 3753 "parser.tab.c" /* yacc.c:1646 */ break; case 193: -#line 661 "parser.y" /* yacc.c:1646 */ - { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); } -#line 3730 "parser.tab.c" /* yacc.c:1646 */ +#line 680 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_enum((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); } +#line 3759 "parser.tab.c" /* yacc.c:1646 */ break; case 194: -#line 664 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr(EXPR_VOID); } -#line 3736 "parser.tab.c" /* yacc.c:1646 */ +#line 683 "parser.y" /* yacc.c:1646 */ + { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); } +#line 3765 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 195: +#line 684 "parser.y" /* yacc.c:1646 */ + { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); } +#line 3771 "parser.tab.c" /* yacc.c:1646 */ break; case 196: -#line 668 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[0].num)); } -#line 3742 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 197: -#line 669 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[0].num)); } -#line 3748 "parser.tab.c" /* yacc.c:1646 */ +#line 687 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr(EXPR_VOID); } +#line 3777 "parser.tab.c" /* yacc.c:1646 */ break; case 198: -#line 670 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[0].dbl)); } -#line 3754 "parser.tab.c" /* yacc.c:1646 */ +#line 691 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[0].num)); } +#line 3783 "parser.tab.c" /* yacc.c:1646 */ break; case 199: -#line 671 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); } -#line 3760 "parser.tab.c" /* yacc.c:1646 */ +#line 692 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[0].num)); } +#line 3789 "parser.tab.c" /* yacc.c:1646 */ break; case 200: -#line 672 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprl(EXPR_NUM, 0); } -#line 3766 "parser.tab.c" /* yacc.c:1646 */ +#line 693 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[0].dbl)); } +#line 3795 "parser.tab.c" /* yacc.c:1646 */ break; case 201: -#line 673 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); } -#line 3772 "parser.tab.c" /* yacc.c:1646 */ +#line 694 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); } +#line 3801 "parser.tab.c" /* yacc.c:1646 */ break; case 202: -#line 674 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[0].str)); } -#line 3778 "parser.tab.c" /* yacc.c:1646 */ +#line 695 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprl(EXPR_NUM, 0); } +#line 3807 "parser.tab.c" /* yacc.c:1646 */ break; case 203: -#line 675 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[0].str)); } -#line 3784 "parser.tab.c" /* yacc.c:1646 */ +#line 696 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); } +#line 3813 "parser.tab.c" /* yacc.c:1646 */ break; case 204: -#line 676 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[0].str)); } -#line 3790 "parser.tab.c" /* yacc.c:1646 */ +#line 697 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[0].str)); } +#line 3819 "parser.tab.c" /* yacc.c:1646 */ break; case 205: -#line 677 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str)); } -#line 3796 "parser.tab.c" /* yacc.c:1646 */ +#line 698 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[0].str)); } +#line 3825 "parser.tab.c" /* yacc.c:1646 */ break; case 206: -#line 678 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3802 "parser.tab.c" /* yacc.c:1646 */ +#line 699 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[0].str)); } +#line 3831 "parser.tab.c" /* yacc.c:1646 */ break; case 207: -#line 679 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3808 "parser.tab.c" /* yacc.c:1646 */ +#line 700 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str)); } +#line 3837 "parser.tab.c" /* yacc.c:1646 */ break; case 208: -#line 680 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3814 "parser.tab.c" /* yacc.c:1646 */ +#line 701 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3843 "parser.tab.c" /* yacc.c:1646 */ break; case 209: -#line 681 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3820 "parser.tab.c" /* yacc.c:1646 */ +#line 702 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3849 "parser.tab.c" /* yacc.c:1646 */ break; case 210: -#line 682 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3826 "parser.tab.c" /* yacc.c:1646 */ +#line 703 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3855 "parser.tab.c" /* yacc.c:1646 */ break; case 211: -#line 683 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3832 "parser.tab.c" /* yacc.c:1646 */ +#line 704 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3861 "parser.tab.c" /* yacc.c:1646 */ break; case 212: -#line 684 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3838 "parser.tab.c" /* yacc.c:1646 */ +#line 705 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3867 "parser.tab.c" /* yacc.c:1646 */ break; case 213: -#line 685 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3844 "parser.tab.c" /* yacc.c:1646 */ +#line 706 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3873 "parser.tab.c" /* yacc.c:1646 */ break; case 214: -#line 686 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3850 "parser.tab.c" /* yacc.c:1646 */ +#line 707 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3879 "parser.tab.c" /* yacc.c:1646 */ break; case 215: -#line 687 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3856 "parser.tab.c" /* yacc.c:1646 */ +#line 708 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3885 "parser.tab.c" /* yacc.c:1646 */ break; case 216: -#line 688 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3862 "parser.tab.c" /* yacc.c:1646 */ +#line 709 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3891 "parser.tab.c" /* yacc.c:1646 */ break; case 217: -#line 689 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3868 "parser.tab.c" /* yacc.c:1646 */ +#line 710 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3897 "parser.tab.c" /* yacc.c:1646 */ break; case 218: -#line 690 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3874 "parser.tab.c" /* yacc.c:1646 */ +#line 711 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3903 "parser.tab.c" /* yacc.c:1646 */ break; case 219: -#line 691 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3880 "parser.tab.c" /* yacc.c:1646 */ +#line 712 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3909 "parser.tab.c" /* yacc.c:1646 */ break; case 220: -#line 692 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3886 "parser.tab.c" /* yacc.c:1646 */ +#line 713 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3915 "parser.tab.c" /* yacc.c:1646 */ break; case 221: -#line 693 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3892 "parser.tab.c" /* yacc.c:1646 */ +#line 714 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3921 "parser.tab.c" /* yacc.c:1646 */ break; case 222: -#line 694 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3898 "parser.tab.c" /* yacc.c:1646 */ +#line 715 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3927 "parser.tab.c" /* yacc.c:1646 */ break; case 223: -#line 695 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3904 "parser.tab.c" /* yacc.c:1646 */ +#line 716 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3933 "parser.tab.c" /* yacc.c:1646 */ break; case 224: -#line 696 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3910 "parser.tab.c" /* yacc.c:1646 */ +#line 717 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3939 "parser.tab.c" /* yacc.c:1646 */ break; case 225: -#line 697 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[0].expr)); } -#line 3916 "parser.tab.c" /* yacc.c:1646 */ +#line 718 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3945 "parser.tab.c" /* yacc.c:1646 */ break; case 226: -#line 698 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[0].expr)); } -#line 3922 "parser.tab.c" /* yacc.c:1646 */ +#line 719 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 3951 "parser.tab.c" /* yacc.c:1646 */ break; case 227: -#line 699 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[0].expr)); } -#line 3928 "parser.tab.c" /* yacc.c:1646 */ +#line 720 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[0].expr)); } +#line 3957 "parser.tab.c" /* yacc.c:1646 */ break; case 228: -#line 700 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[0].expr)); } -#line 3934 "parser.tab.c" /* yacc.c:1646 */ +#line 721 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[0].expr)); } +#line 3963 "parser.tab.c" /* yacc.c:1646 */ break; case 229: -#line 701 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[0].expr)); } -#line 3940 "parser.tab.c" /* yacc.c:1646 */ +#line 722 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[0].expr)); } +#line 3969 "parser.tab.c" /* yacc.c:1646 */ break; case 230: -#line 702 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[0].expr)); } -#line 3946 "parser.tab.c" /* yacc.c:1646 */ +#line 723 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[0].expr)); } +#line 3975 "parser.tab.c" /* yacc.c:1646 */ break; case 231: -#line 703 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[-2].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); } -#line 3952 "parser.tab.c" /* yacc.c:1646 */ +#line 724 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[0].expr)); } +#line 3981 "parser.tab.c" /* yacc.c:1646 */ break; case 232: -#line 704 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[-2].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); } -#line 3958 "parser.tab.c" /* yacc.c:1646 */ +#line 725 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[0].expr)); } +#line 3987 "parser.tab.c" /* yacc.c:1646 */ break; case 233: -#line 706 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprt(EXPR_CAST, declare_var(NULL, (yyvsp[-3].declspec), (yyvsp[-2].declarator), 0), (yyvsp[0].expr)); free((yyvsp[-3].declspec)); free((yyvsp[-2].declarator)); } -#line 3964 "parser.tab.c" /* yacc.c:1646 */ +#line 726 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[-2].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); } +#line 3993 "parser.tab.c" /* yacc.c:1646 */ break; case 234: -#line 708 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_exprt(EXPR_SIZEOF, declare_var(NULL, (yyvsp[-2].declspec), (yyvsp[-1].declarator), 0), NULL); free((yyvsp[-2].declspec)); free((yyvsp[-1].declarator)); } -#line 3970 "parser.tab.c" /* yacc.c:1646 */ +#line 727 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[-2].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); } +#line 3999 "parser.tab.c" /* yacc.c:1646 */ break; case 235: -#line 709 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } -#line 3976 "parser.tab.c" /* yacc.c:1646 */ +#line 729 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprt(EXPR_CAST, declare_var(NULL, (yyvsp[-3].declspec), (yyvsp[-2].declarator), 0), (yyvsp[0].expr)); free((yyvsp[-3].declspec)); free((yyvsp[-2].declarator)); } +#line 4005 "parser.tab.c" /* yacc.c:1646 */ break; case 236: -#line 710 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = (yyvsp[-1].expr); } -#line 3982 "parser.tab.c" /* yacc.c:1646 */ +#line 731 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_exprt(EXPR_SIZEOF, declare_var(NULL, (yyvsp[-2].declspec), (yyvsp[-1].declarator), 0), NULL); free((yyvsp[-2].declspec)); free((yyvsp[-1].declarator)); } +#line 4011 "parser.tab.c" /* yacc.c:1646 */ break; case 237: -#line 713 "parser.y" /* yacc.c:1646 */ - { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); } -#line 3988 "parser.tab.c" /* yacc.c:1646 */ +#line 732 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } +#line 4017 "parser.tab.c" /* yacc.c:1646 */ break; case 238: -#line 714 "parser.y" /* yacc.c:1646 */ - { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); } -#line 3994 "parser.tab.c" /* yacc.c:1646 */ +#line 733 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = (yyvsp[-1].expr); } +#line 4023 "parser.tab.c" /* yacc.c:1646 */ break; case 239: -#line 717 "parser.y" /* yacc.c:1646 */ +#line 736 "parser.y" /* yacc.c:1646 */ + { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); } +#line 4029 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 240: +#line 737 "parser.y" /* yacc.c:1646 */ + { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); } +#line 4035 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 241: +#line 740 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); if (!(yyval.expr)->is_const) error_loc("expression is not an integer constant\n"); } -#line 4003 "parser.tab.c" /* yacc.c:1646 */ +#line 4044 "parser.tab.c" /* yacc.c:1646 */ break; - case 240: -#line 723 "parser.y" /* yacc.c:1646 */ + case 242: +#line 746 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); if (!(yyval.expr)->is_const && (yyval.expr)->type != EXPR_STRLIT && (yyval.expr)->type != EXPR_WSTRLIT) error_loc("expression is not constant\n"); } -#line 4012 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 241: -#line 729 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = NULL; } -#line 4018 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 242: -#line 730 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = append_var_list((yyvsp[-1].var_list), (yyvsp[0].var_list)); } -#line 4024 "parser.tab.c" /* yacc.c:1646 */ +#line 4053 "parser.tab.c" /* yacc.c:1646 */ break; case 243: -#line 734 "parser.y" /* yacc.c:1646 */ +#line 752 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = NULL; } +#line 4059 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 244: +#line 753 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = append_var_list((yyvsp[-1].var_list), (yyvsp[0].var_list)); } +#line 4065 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 245: +#line 757 "parser.y" /* yacc.c:1646 */ { const char *first = LIST_ENTRY(list_head((yyvsp[-1].declarator_list)), declarator_t, entry)->var->name; check_field_attrs(first, (yyvsp[-3].attr_list)); (yyval.var_list) = set_var_types((yyvsp[-3].attr_list), (yyvsp[-2].declspec), (yyvsp[-1].declarator_list)); } -#line 4033 "parser.tab.c" /* yacc.c:1646 */ +#line 4074 "parser.tab.c" /* yacc.c:1646 */ break; - case 244: -#line 738 "parser.y" /* yacc.c:1646 */ + case 246: +#line 761 "parser.y" /* yacc.c:1646 */ { var_t *v = make_var(NULL); v->type = (yyvsp[-1].type); v->attrs = (yyvsp[-2].attr_list); (yyval.var_list) = append_var(NULL, v); } -#line 4042 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 245: -#line 745 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = (yyvsp[-1].var); } -#line 4048 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 246: -#line 746 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[-1].attr_list); } -#line 4054 "parser.tab.c" /* yacc.c:1646 */ +#line 4083 "parser.tab.c" /* yacc.c:1646 */ break; case 247: -#line 749 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = NULL; } -#line 4060 "parser.tab.c" /* yacc.c:1646 */ +#line 768 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = (yyvsp[-1].var); } +#line 4089 "parser.tab.c" /* yacc.c:1646 */ break; case 248: -#line 750 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); } -#line 4066 "parser.tab.c" /* yacc.c:1646 */ +#line 769 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[-1].attr_list); } +#line 4095 "parser.tab.c" /* yacc.c:1646 */ break; case 249: -#line 754 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = (yyvsp[-1].var); } -#line 4072 "parser.tab.c" /* yacc.c:1646 */ +#line 772 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = NULL; } +#line 4101 "parser.tab.c" /* yacc.c:1646 */ break; case 250: -#line 755 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = NULL; } -#line 4078 "parser.tab.c" /* yacc.c:1646 */ +#line 773 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); } +#line 4107 "parser.tab.c" /* yacc.c:1646 */ break; case 251: -#line 758 "parser.y" /* yacc.c:1646 */ +#line 777 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = (yyvsp[-1].var); } +#line 4113 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 252: +#line 778 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = NULL; } +#line 4119 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 253: +#line 781 "parser.y" /* yacc.c:1646 */ { (yyval.var) = declare_var(check_field_attrs((yyvsp[0].declarator)->var->name, (yyvsp[-2].attr_list)), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); free((yyvsp[0].declarator)); } -#line 4087 "parser.tab.c" /* yacc.c:1646 */ +#line 4128 "parser.tab.c" /* yacc.c:1646 */ break; - case 252: -#line 762 "parser.y" /* yacc.c:1646 */ + case 254: +#line 785 "parser.y" /* yacc.c:1646 */ { var_t *v = make_var(NULL); v->type = (yyvsp[0].type); v->attrs = (yyvsp[-1].attr_list); (yyval.var) = v; } -#line 4096 "parser.tab.c" /* yacc.c:1646 */ +#line 4137 "parser.tab.c" /* yacc.c:1646 */ break; - case 253: -#line 768 "parser.y" /* yacc.c:1646 */ + case 255: +#line 791 "parser.y" /* yacc.c:1646 */ { (yyval.var) = (yyvsp[0].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); } -#line 4106 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 254: -#line 777 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); - free((yyvsp[0].declarator)); - } -#line 4114 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 255: -#line 780 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); - free((yyvsp[0].declarator)); - } -#line 4122 "parser.tab.c" /* yacc.c:1646 */ +#line 4147 "parser.tab.c" /* yacc.c:1646 */ break; case 256: -#line 785 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = NULL; } -#line 4128 "parser.tab.c" /* yacc.c:1646 */ +#line 800 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); + free((yyvsp[0].declarator)); + } +#line 4155 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 257: +#line 803 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); + free((yyvsp[0].declarator)); + } +#line 4163 "parser.tab.c" /* yacc.c:1646 */ break; case 258: -#line 789 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = NULL; } -#line 4134 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 259: -#line 790 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[0].str); } -#line 4140 "parser.tab.c" /* yacc.c:1646 */ +#line 808 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = NULL; } +#line 4169 "parser.tab.c" /* yacc.c:1646 */ break; case 260: -#line 791 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[0].str); } -#line 4146 "parser.tab.c" /* yacc.c:1646 */ +#line 812 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = NULL; } +#line 4175 "parser.tab.c" /* yacc.c:1646 */ break; case 261: -#line 794 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = make_var((yyvsp[0].str)); } -#line 4152 "parser.tab.c" /* yacc.c:1646 */ +#line 813 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[0].str); } +#line 4181 "parser.tab.c" /* yacc.c:1646 */ break; case 262: -#line 796 "parser.y" /* yacc.c:1646 */ - { (yyval.var) = make_var((yyvsp[0].str)); } -#line 4158 "parser.tab.c" /* yacc.c:1646 */ +#line 814 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[0].str); } +#line 4187 "parser.tab.c" /* yacc.c:1646 */ break; case 263: -#line 799 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4164 "parser.tab.c" /* yacc.c:1646 */ +#line 817 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = make_var((yyvsp[0].str)); } +#line 4193 "parser.tab.c" /* yacc.c:1646 */ break; case 264: -#line 800 "parser.y" /* yacc.c:1646 */ +#line 819 "parser.y" /* yacc.c:1646 */ + { (yyval.var) = make_var((yyvsp[0].str)); } +#line 4199 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 265: +#line 822 "parser.y" /* yacc.c:1646 */ { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4170 "parser.tab.c" /* yacc.c:1646 */ +#line 4205 "parser.tab.c" /* yacc.c:1646 */ break; case 266: -#line 802 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), -1); } -#line 4176 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 267: -#line 803 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), 1); } -#line 4182 "parser.tab.c" /* yacc.c:1646 */ +#line 823 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } +#line 4211 "parser.tab.c" /* yacc.c:1646 */ break; case 268: -#line 804 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); } -#line 4188 "parser.tab.c" /* yacc.c:1646 */ +#line 825 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), -1); } +#line 4217 "parser.tab.c" /* yacc.c:1646 */ break; case 269: -#line 805 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4194 "parser.tab.c" /* yacc.c:1646 */ +#line 826 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), 1); } +#line 4223 "parser.tab.c" /* yacc.c:1646 */ break; case 270: -#line 806 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4200 "parser.tab.c" /* yacc.c:1646 */ +#line 827 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); } +#line 4229 "parser.tab.c" /* yacc.c:1646 */ break; case 271: -#line 807 "parser.y" /* yacc.c:1646 */ +#line 828 "parser.y" /* yacc.c:1646 */ { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4206 "parser.tab.c" /* yacc.c:1646 */ +#line 4235 "parser.tab.c" /* yacc.c:1646 */ break; case 272: -#line 808 "parser.y" /* yacc.c:1646 */ +#line 829 "parser.y" /* yacc.c:1646 */ { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4212 "parser.tab.c" /* yacc.c:1646 */ +#line 4241 "parser.tab.c" /* yacc.c:1646 */ break; case 273: -#line 809 "parser.y" /* yacc.c:1646 */ +#line 830 "parser.y" /* yacc.c:1646 */ { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } -#line 4218 "parser.tab.c" /* yacc.c:1646 */ +#line 4247 "parser.tab.c" /* yacc.c:1646 */ break; - case 276: -#line 816 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); } -#line 4224 "parser.tab.c" /* yacc.c:1646 */ + case 274: +#line 831 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } +#line 4253 "parser.tab.c" /* yacc.c:1646 */ break; - case 277: -#line 817 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); } -#line 4230 "parser.tab.c" /* yacc.c:1646 */ + case 275: +#line 832 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } +#line 4259 "parser.tab.c" /* yacc.c:1646 */ break; case 278: -#line 818 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); } -#line 4236 "parser.tab.c" /* yacc.c:1646 */ +#line 839 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); } +#line 4265 "parser.tab.c" /* yacc.c:1646 */ break; case 279: -#line 819 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); } -#line 4242 "parser.tab.c" /* yacc.c:1646 */ +#line 840 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); } +#line 4271 "parser.tab.c" /* yacc.c:1646 */ break; case 280: -#line 820 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); } -#line 4248 "parser.tab.c" /* yacc.c:1646 */ +#line 841 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); } +#line 4277 "parser.tab.c" /* yacc.c:1646 */ break; case 281: -#line 821 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); } -#line 4254 "parser.tab.c" /* yacc.c:1646 */ +#line 842 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_LONG, 0); } +#line 4283 "parser.tab.c" /* yacc.c:1646 */ break; case 282: -#line 822 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); } -#line 4260 "parser.tab.c" /* yacc.c:1646 */ +#line 843 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); } +#line 4289 "parser.tab.c" /* yacc.c:1646 */ break; case 283: -#line 823 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); } -#line 4266 "parser.tab.c" /* yacc.c:1646 */ +#line 844 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); } +#line 4295 "parser.tab.c" /* yacc.c:1646 */ break; case 284: -#line 826 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_coclass((yyvsp[0].str)); } -#line 4272 "parser.tab.c" /* yacc.c:1646 */ +#line 845 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); } +#line 4301 "parser.tab.c" /* yacc.c:1646 */ break; case 285: -#line 827 "parser.y" /* yacc.c:1646 */ +#line 846 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); } +#line 4307 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 286: +#line 847 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); } +#line 4313 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 287: +#line 850 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_coclass((yyvsp[0].str)); } +#line 4319 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 288: +#line 851 "parser.y" /* yacc.c:1646 */ { (yyval.type) = find_type((yyvsp[0].str), NULL, 0); if (type_get_type_detect_alias((yyval.type)) != TYPE_COCLASS) error_loc("%s was not declared a coclass at %s:%d\n", (yyvsp[0].str), (yyval.type)->loc_info.input_name, (yyval.type)->loc_info.line_number); } -#line 4283 "parser.tab.c" /* yacc.c:1646 */ +#line 4330 "parser.tab.c" /* yacc.c:1646 */ break; - case 286: -#line 835 "parser.y" /* yacc.c:1646 */ + case 289: +#line 859 "parser.y" /* yacc.c:1646 */ { (yyval.type) = (yyvsp[0].type); check_def((yyval.type)); (yyval.type)->attrs = check_coclass_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); } -#line 4292 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 287: -#line 842 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_coclass_define((yyvsp[-4].type), (yyvsp[-2].ifref_list)); } -#line 4298 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 288: -#line 845 "parser.y" /* yacc.c:1646 */ - { (yyval.str) = (yyvsp[0].str); } -#line 4304 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 289: -#line 848 "parser.y" /* yacc.c:1646 */ - { (yyval.ifref_list) = NULL; } -#line 4310 "parser.tab.c" /* yacc.c:1646 */ +#line 4339 "parser.tab.c" /* yacc.c:1646 */ break; case 290: -#line 849 "parser.y" /* yacc.c:1646 */ - { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), (yyvsp[0].ifref) ); } -#line 4316 "parser.tab.c" /* yacc.c:1646 */ +#line 866 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_coclass_define((yyvsp[-4].type), (yyvsp[-2].ifref_list)); } +#line 4345 "parser.tab.c" /* yacc.c:1646 */ break; case 291: -#line 853 "parser.y" /* yacc.c:1646 */ - { (yyval.ifref) = make_ifref((yyvsp[0].type)); (yyval.ifref)->attrs = (yyvsp[-1].attr_list); } -#line 4322 "parser.tab.c" /* yacc.c:1646 */ +#line 869 "parser.y" /* yacc.c:1646 */ + { (yyval.str) = (yyvsp[0].str); } +#line 4351 "parser.tab.c" /* yacc.c:1646 */ break; case 292: -#line 856 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } -#line 4328 "parser.tab.c" /* yacc.c:1646 */ +#line 872 "parser.y" /* yacc.c:1646 */ + { (yyval.ifref_list) = NULL; } +#line 4357 "parser.tab.c" /* yacc.c:1646 */ break; case 293: -#line 857 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } -#line 4334 "parser.tab.c" /* yacc.c:1646 */ +#line 873 "parser.y" /* yacc.c:1646 */ + { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), (yyvsp[0].ifref) ); } +#line 4363 "parser.tab.c" /* yacc.c:1646 */ break; case 294: -#line 860 "parser.y" /* yacc.c:1646 */ +#line 877 "parser.y" /* yacc.c:1646 */ + { (yyval.ifref) = make_ifref((yyvsp[0].type)); (yyval.ifref)->attrs = (yyvsp[-1].attr_list); } +#line 4369 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 295: +#line 880 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } +#line 4375 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 296: +#line 881 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } +#line 4381 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 297: +#line 884 "parser.y" /* yacc.c:1646 */ { attr_t *attrs; (yyval.type) = (yyvsp[0].type); check_def((yyval.type)); @@ -4342,75 +4389,75 @@ yyreduce: (yyval.type)->attrs = append_attr( check_dispiface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)), attrs ); (yyval.type)->defined = TRUE; } -#line 4346 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 295: -#line 869 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = NULL; } -#line 4352 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 296: -#line 870 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); } -#line 4358 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 297: -#line 873 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = NULL; } -#line 4364 "parser.tab.c" /* yacc.c:1646 */ +#line 4393 "parser.tab.c" /* yacc.c:1646 */ break; case 298: -#line 874 "parser.y" /* yacc.c:1646 */ - { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); } -#line 4370 "parser.tab.c" /* yacc.c:1646 */ +#line 893 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = NULL; } +#line 4399 "parser.tab.c" /* yacc.c:1646 */ break; case 299: -#line 880 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[-4].type); - type_dispinterface_define((yyval.type), (yyvsp[-2].var_list), (yyvsp[-1].var_list)); - } -#line 4378 "parser.tab.c" /* yacc.c:1646 */ +#line 894 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); } +#line 4405 "parser.tab.c" /* yacc.c:1646 */ break; case 300: -#line 884 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[-4].type); - type_dispinterface_define_from_iface((yyval.type), (yyvsp[-2].type)); - } -#line 4386 "parser.tab.c" /* yacc.c:1646 */ +#line 897 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = NULL; } +#line 4411 "parser.tab.c" /* yacc.c:1646 */ break; case 301: -#line 889 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = NULL; } -#line 4392 "parser.tab.c" /* yacc.c:1646 */ +#line 898 "parser.y" /* yacc.c:1646 */ + { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); } +#line 4417 "parser.tab.c" /* yacc.c:1646 */ break; case 302: -#line 890 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = find_type_or_error2((yyvsp[0].str), 0); } -#line 4398 "parser.tab.c" /* yacc.c:1646 */ +#line 904 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[-4].type); + type_dispinterface_define((yyval.type), (yyvsp[-2].var_list), (yyvsp[-1].var_list)); + } +#line 4425 "parser.tab.c" /* yacc.c:1646 */ break; case 303: -#line 893 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } -#line 4404 "parser.tab.c" /* yacc.c:1646 */ +#line 908 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[-4].type); + type_dispinterface_define_from_iface((yyval.type), (yyvsp[-2].type)); + } +#line 4433 "parser.tab.c" /* yacc.c:1646 */ break; case 304: -#line 894 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } -#line 4410 "parser.tab.c" /* yacc.c:1646 */ +#line 913 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = NULL; } +#line 4439 "parser.tab.c" /* yacc.c:1646 */ break; case 305: -#line 897 "parser.y" /* yacc.c:1646 */ +#line 914 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = find_type_or_error2((yyvsp[0].str), 0); } +#line 4445 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 306: +#line 917 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } +#line 4451 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 307: +#line 918 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } +#line 4457 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 308: +#line 921 "parser.y" /* yacc.c:1646 */ { (yyval.ifinfo).interface = (yyvsp[0].type); (yyval.ifinfo).old_pointer_default = pointer_default; if (is_attr((yyvsp[-1].attr_list), ATTR_POINTERDEFAULT)) @@ -4419,545 +4466,606 @@ yyreduce: (yyvsp[0].type)->attrs = check_iface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); (yyvsp[0].type)->defined = TRUE; } -#line 4423 "parser.tab.c" /* yacc.c:1646 */ +#line 4470 "parser.tab.c" /* yacc.c:1646 */ break; - case 306: -#line 908 "parser.y" /* yacc.c:1646 */ + case 309: +#line 932 "parser.y" /* yacc.c:1646 */ { (yyval.type) = (yyvsp[-5].ifinfo).interface; if((yyval.type) == (yyvsp[-4].type)) error_loc("Interface can't inherit from itself\n"); type_interface_define((yyval.type), (yyvsp[-4].type), (yyvsp[-2].stmt_list)); + check_async_uuid((yyval.type)); pointer_default = (yyvsp[-5].ifinfo).old_pointer_default; } -#line 4434 "parser.tab.c" /* yacc.c:1646 */ +#line 4482 "parser.tab.c" /* yacc.c:1646 */ break; - case 307: -#line 918 "parser.y" /* yacc.c:1646 */ + case 310: +#line 943 "parser.y" /* yacc.c:1646 */ { (yyval.type) = (yyvsp[-7].ifinfo).interface; type_interface_define((yyval.type), find_type_or_error2((yyvsp[-5].str), 0), (yyvsp[-2].stmt_list)); pointer_default = (yyvsp[-7].ifinfo).old_pointer_default; } -#line 4443 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 308: -#line 922 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[-1].type); } -#line 4449 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 309: -#line 926 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[-1].type); } -#line 4455 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 310: -#line 927 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[-1].type); } -#line 4461 "parser.tab.c" /* yacc.c:1646 */ +#line 4491 "parser.tab.c" /* yacc.c:1646 */ break; case 311: -#line 930 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_module((yyvsp[0].str)); } -#line 4467 "parser.tab.c" /* yacc.c:1646 */ +#line 947 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[-1].type); } +#line 4497 "parser.tab.c" /* yacc.c:1646 */ break; case 312: -#line 931 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_module((yyvsp[0].str)); } -#line 4473 "parser.tab.c" /* yacc.c:1646 */ +#line 951 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[-1].type); } +#line 4503 "parser.tab.c" /* yacc.c:1646 */ break; case 313: -#line 934 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); - (yyval.type)->attrs = check_module_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); - } -#line 4481 "parser.tab.c" /* yacc.c:1646 */ +#line 952 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[-1].type); } +#line 4509 "parser.tab.c" /* yacc.c:1646 */ break; case 314: -#line 940 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[-4].type); - type_module_define((yyval.type), (yyvsp[-2].stmt_list)); - } -#line 4489 "parser.tab.c" /* yacc.c:1646 */ +#line 955 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_module((yyvsp[0].str)); } +#line 4515 "parser.tab.c" /* yacc.c:1646 */ break; case 315: -#line 946 "parser.y" /* yacc.c:1646 */ - { (yyval.stgclass) = STG_EXTERN; } -#line 4495 "parser.tab.c" /* yacc.c:1646 */ +#line 956 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_module((yyvsp[0].str)); } +#line 4521 "parser.tab.c" /* yacc.c:1646 */ break; case 316: -#line 947 "parser.y" /* yacc.c:1646 */ - { (yyval.stgclass) = STG_STATIC; } -#line 4501 "parser.tab.c" /* yacc.c:1646 */ +#line 959 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); + (yyval.type)->attrs = check_module_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); + } +#line 4529 "parser.tab.c" /* yacc.c:1646 */ break; case 317: -#line 948 "parser.y" /* yacc.c:1646 */ - { (yyval.stgclass) = STG_REGISTER; } -#line 4507 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 318: -#line 952 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_INLINE); } -#line 4513 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 319: -#line 956 "parser.y" /* yacc.c:1646 */ - { (yyval.attr) = make_attr(ATTR_CONST); } -#line 4519 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 320: -#line 959 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = NULL; } -#line 4525 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 321: -#line 960 "parser.y" /* yacc.c:1646 */ - { (yyval.attr_list) = append_attr((yyvsp[-1].attr_list), (yyvsp[0].attr)); } -#line 4531 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 322: -#line 963 "parser.y" /* yacc.c:1646 */ - { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[0].declspec), NULL, NULL, STG_NONE); } +#line 965 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[-4].type); + type_module_define((yyval.type), (yyvsp[-2].stmt_list)); + } #line 4537 "parser.tab.c" /* yacc.c:1646 */ break; - case 323: -#line 965 "parser.y" /* yacc.c:1646 */ - { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[-2].declspec), (yyvsp[0].declspec), NULL, STG_NONE); } + case 318: +#line 971 "parser.y" /* yacc.c:1646 */ + { (yyval.stgclass) = STG_EXTERN; } #line 4543 "parser.tab.c" /* yacc.c:1646 */ break; - case 324: -#line 968 "parser.y" /* yacc.c:1646 */ - { (yyval.declspec) = NULL; } + case 319: +#line 972 "parser.y" /* yacc.c:1646 */ + { (yyval.stgclass) = STG_STATIC; } #line 4549 "parser.tab.c" /* yacc.c:1646 */ break; - case 326: + case 320: #line 973 "parser.y" /* yacc.c:1646 */ - { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); } + { (yyval.stgclass) = STG_REGISTER; } #line 4555 "parser.tab.c" /* yacc.c:1646 */ break; - case 327: -#line 974 "parser.y" /* yacc.c:1646 */ - { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); } + case 321: +#line 977 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_INLINE); } #line 4561 "parser.tab.c" /* yacc.c:1646 */ break; - case 328: -#line 975 "parser.y" /* yacc.c:1646 */ - { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, NULL, (yyvsp[-1].stgclass)); } + case 322: +#line 981 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_CONST); } #line 4567 "parser.tab.c" /* yacc.c:1646 */ break; - case 329: -#line 980 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } + case 323: +#line 984 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = NULL; } #line 4573 "parser.tab.c" /* yacc.c:1646 */ break; + case 324: +#line 985 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = append_attr((yyvsp[-1].attr_list), (yyvsp[0].attr)); } +#line 4579 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 325: +#line 988 "parser.y" /* yacc.c:1646 */ + { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[0].declspec), NULL, NULL, STG_NONE); } +#line 4585 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 326: +#line 990 "parser.y" /* yacc.c:1646 */ + { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[-2].declspec), (yyvsp[0].declspec), NULL, STG_NONE); } +#line 4591 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 327: +#line 993 "parser.y" /* yacc.c:1646 */ + { (yyval.declspec) = NULL; } +#line 4597 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 329: +#line 998 "parser.y" /* yacc.c:1646 */ + { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); } +#line 4603 "parser.tab.c" /* yacc.c:1646 */ + break; + case 330: -#line 981 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); - else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } -#line 4580 "parser.tab.c" /* yacc.c:1646 */ +#line 999 "parser.y" /* yacc.c:1646 */ + { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); } +#line 4609 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 331: +#line 1000 "parser.y" /* yacc.c:1646 */ + { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, NULL, (yyvsp[-1].stgclass)); } +#line 4615 "parser.tab.c" /* yacc.c:1646 */ break; case 332: -#line 987 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator((yyvsp[0].var)); } -#line 4586 "parser.tab.c" /* yacc.c:1646 */ +#line 1005 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } +#line 4621 "parser.tab.c" /* yacc.c:1646 */ break; case 333: -#line 988 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-1].declarator); } -#line 4592 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 334: -#line 989 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } -#line 4598 "parser.tab.c" /* yacc.c:1646 */ +#line 1006 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); + else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } +#line 4628 "parser.tab.c" /* yacc.c:1646 */ break; case 335: -#line 990 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-3].declarator); - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); - (yyval.declarator)->type = NULL; - } -#line 4607 "parser.tab.c" /* yacc.c:1646 */ +#line 1012 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = make_declarator((yyvsp[0].var)); } +#line 4634 "parser.tab.c" /* yacc.c:1646 */ break; case 336: -#line 999 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } -#line 4613 "parser.tab.c" /* yacc.c:1646 */ +#line 1013 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-1].declarator); } +#line 4640 "parser.tab.c" /* yacc.c:1646 */ break; case 337: -#line 1000 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); - else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } -#line 4620 "parser.tab.c" /* yacc.c:1646 */ +#line 1014 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } +#line 4646 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 338: +#line 1015 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-3].declarator); + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); + (yyval.declarator)->type = NULL; + } +#line 4655 "parser.tab.c" /* yacc.c:1646 */ break; case 339: -#line 1008 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } -#line 4626 "parser.tab.c" /* yacc.c:1646 */ +#line 1024 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } +#line 4661 "parser.tab.c" /* yacc.c:1646 */ break; case 340: -#line 1009 "parser.y" /* yacc.c:1646 */ +#line 1025 "parser.y" /* yacc.c:1646 */ { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } -#line 4633 "parser.tab.c" /* yacc.c:1646 */ +#line 4668 "parser.tab.c" /* yacc.c:1646 */ break; - case 341: -#line 1014 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator(NULL); } -#line 4639 "parser.tab.c" /* yacc.c:1646 */ + case 342: +#line 1033 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } +#line 4674 "parser.tab.c" /* yacc.c:1646 */ break; case 343: -#line 1020 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-1].declarator); } -#line 4645 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 344: -#line 1021 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } -#line 4651 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 345: -#line 1022 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } -#line 4657 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 346: -#line 1024 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator(NULL); - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); - (yyval.declarator)->type = NULL; - } -#line 4666 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 347: -#line 1029 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-3].declarator); - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); - (yyval.declarator)->type = NULL; - } -#line 4675 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 348: -#line 1038 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } +#line 1034 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); + else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } #line 4681 "parser.tab.c" /* yacc.c:1646 */ break; - case 349: + case 344: #line 1039 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } + { (yyval.declarator) = make_declarator(NULL); } #line 4687 "parser.tab.c" /* yacc.c:1646 */ break; - case 351: -#line 1046 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } + case 346: +#line 1045 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-1].declarator); } #line 4693 "parser.tab.c" /* yacc.c:1646 */ break; - case 352: -#line 1047 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } + case 347: +#line 1046 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } #line 4699 "parser.tab.c" /* yacc.c:1646 */ break; - case 353: -#line 1051 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator(NULL); } + case 348: +#line 1047 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } #line 4705 "parser.tab.c" /* yacc.c:1646 */ break; - case 355: -#line 1059 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator((yyvsp[0].var)); } -#line 4711 "parser.tab.c" /* yacc.c:1646 */ + case 349: +#line 1049 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = make_declarator(NULL); + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); + (yyval.declarator)->type = NULL; + } +#line 4714 "parser.tab.c" /* yacc.c:1646 */ break; - case 356: -#line 1060 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-1].declarator); } -#line 4717 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 357: -#line 1061 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } + case 350: +#line 1054 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-3].declarator); + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); + (yyval.declarator)->type = NULL; + } #line 4723 "parser.tab.c" /* yacc.c:1646 */ break; - case 358: -#line 1062 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } + case 351: +#line 1063 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } #line 4729 "parser.tab.c" /* yacc.c:1646 */ break; - case 359: + case 352: #line 1064 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = make_declarator(NULL); - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); - (yyval.declarator)->type = NULL; - } -#line 4738 "parser.tab.c" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } +#line 4735 "parser.tab.c" /* yacc.c:1646 */ break; - case 360: -#line 1069 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-3].declarator); - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); - (yyval.declarator)->type = NULL; - } + case 354: +#line 1071 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } +#line 4741 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 355: +#line 1072 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } #line 4747 "parser.tab.c" /* yacc.c:1646 */ break; - case 361: + case 356: #line 1076 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); } + { (yyval.declarator) = make_declarator(NULL); } #line 4753 "parser.tab.c" /* yacc.c:1646 */ break; - case 362: -#line 1077 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); } + case 358: +#line 1084 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = make_declarator((yyvsp[0].var)); } #line 4759 "parser.tab.c" /* yacc.c:1646 */ break; - case 363: -#line 1080 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = NULL; } + case 359: +#line 1085 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-1].declarator); } #line 4765 "parser.tab.c" /* yacc.c:1646 */ break; - case 364: -#line 1081 "parser.y" /* yacc.c:1646 */ - { (yyval.expr) = (yyvsp[0].expr); } + case 360: +#line 1086 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } #line 4771 "parser.tab.c" /* yacc.c:1646 */ break; + case 361: +#line 1087 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } +#line 4777 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 362: +#line 1089 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = make_declarator(NULL); + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); + (yyval.declarator)->type = NULL; + } +#line 4786 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 363: +#line 1094 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-3].declarator); + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); + (yyval.declarator)->type = NULL; + } +#line 4795 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 364: +#line 1101 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); } +#line 4801 "parser.tab.c" /* yacc.c:1646 */ + break; + case 365: -#line 1084 "parser.y" /* yacc.c:1646 */ +#line 1102 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); } +#line 4807 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 366: +#line 1105 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = NULL; } +#line 4813 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 367: +#line 1106 "parser.y" /* yacc.c:1646 */ + { (yyval.expr) = (yyvsp[0].expr); } +#line 4819 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 368: +#line 1109 "parser.y" /* yacc.c:1646 */ { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->bits = (yyvsp[0].expr); if (!(yyval.declarator)->bits && !(yyval.declarator)->var->name) error_loc("unnamed fields are not allowed\n"); } -#line 4780 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 366: -#line 1091 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); } -#line 4786 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 367: -#line 1093 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); } -#line 4792 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 368: -#line 1097 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[0].declarator); } -#line 4798 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 369: -#line 1098 "parser.y" /* yacc.c:1646 */ - { (yyval.declarator) = (yyvsp[-2].declarator); (yyvsp[-2].declarator)->var->eval = (yyvsp[0].expr); } -#line 4804 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 370: -#line 1102 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = THREADING_APARTMENT; } -#line 4810 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 371: -#line 1103 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = THREADING_NEUTRAL; } -#line 4816 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 372: -#line 1104 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = THREADING_SINGLE; } -#line 4822 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 373: -#line 1105 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = THREADING_FREE; } #line 4828 "parser.tab.c" /* yacc.c:1646 */ break; - case 374: -#line 1106 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = THREADING_BOTH; } + case 369: +#line 1116 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); } #line 4834 "parser.tab.c" /* yacc.c:1646 */ break; - case 375: -#line 1110 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = RPC_FC_RP; } + case 370: +#line 1118 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); } #line 4840 "parser.tab.c" /* yacc.c:1646 */ break; - case 376: -#line 1111 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = RPC_FC_UP; } + case 371: +#line 1122 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[0].declarator); } #line 4846 "parser.tab.c" /* yacc.c:1646 */ break; - case 377: -#line 1112 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = RPC_FC_FP; } + case 372: +#line 1123 "parser.y" /* yacc.c:1646 */ + { (yyval.declarator) = (yyvsp[-2].declarator); (yyvsp[-2].declarator)->var->eval = (yyvsp[0].expr); } #line 4852 "parser.tab.c" /* yacc.c:1646 */ break; - case 378: -#line 1115 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_struct((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); } + case 373: +#line 1127 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = THREADING_APARTMENT; } #line 4858 "parser.tab.c" /* yacc.c:1646 */ break; - case 379: -#line 1118 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_void(); } + case 374: +#line 1128 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = THREADING_NEUTRAL; } #line 4864 "parser.tab.c" /* yacc.c:1646 */ break; - case 380: -#line 1119 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } + case 375: +#line 1129 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = THREADING_SINGLE; } #line 4870 "parser.tab.c" /* yacc.c:1646 */ break; - case 381: -#line 1120 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); } + case 376: +#line 1130 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = THREADING_FREE; } #line 4876 "parser.tab.c" /* yacc.c:1646 */ break; - case 382: -#line 1121 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); } + case 377: +#line 1131 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = THREADING_BOTH; } #line 4882 "parser.tab.c" /* yacc.c:1646 */ break; - case 383: -#line 1122 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); } + case 378: +#line 1135 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = FC_RP; } #line 4888 "parser.tab.c" /* yacc.c:1646 */ break; - case 384: -#line 1123 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); } + case 379: +#line 1136 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = FC_UP; } #line 4894 "parser.tab.c" /* yacc.c:1646 */ break; - case 385: -#line 1124 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); } + case 380: +#line 1137 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = FC_FP; } #line 4900 "parser.tab.c" /* yacc.c:1646 */ break; - case 386: -#line 1125 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = (yyvsp[0].type); } + case 381: +#line 1140 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_struct((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); } #line 4906 "parser.tab.c" /* yacc.c:1646 */ break; - case 387: -#line 1126 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); } + case 382: +#line 1143 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_void(); } #line 4912 "parser.tab.c" /* yacc.c:1646 */ break; - case 388: -#line 1127 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = make_safearray((yyvsp[-1].type)); } + case 383: +#line 1144 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } #line 4918 "parser.tab.c" /* yacc.c:1646 */ break; + case 384: +#line 1145 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); } +#line 4924 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 385: +#line 1146 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); } +#line 4930 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 386: +#line 1147 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); } +#line 4936 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 387: +#line 1148 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); } +#line 4942 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 388: +#line 1149 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); } +#line 4948 "parser.tab.c" /* yacc.c:1646 */ + break; + case 389: -#line 1131 "parser.y" /* yacc.c:1646 */ +#line 1150 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = (yyvsp[0].type); } +#line 4954 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 390: +#line 1151 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); } +#line 4960 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 391: +#line 1152 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = make_safearray((yyvsp[-1].type)); } +#line 4966 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 392: +#line 1156 "parser.y" /* yacc.c:1646 */ { (yyvsp[-4].attr_list) = append_attribs((yyvsp[-4].attr_list), (yyvsp[-2].attr_list)); reg_typedefs((yyvsp[-1].declspec), (yyvsp[0].declarator_list), check_typedef_attrs((yyvsp[-4].attr_list))); (yyval.statement) = make_statement_typedef((yyvsp[0].declarator_list)); } -#line 4927 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 390: -#line 1138 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_nonencapsulated_union((yyvsp[-3].str), TRUE, (yyvsp[-1].var_list)); } -#line 4933 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 391: -#line 1141 "parser.y" /* yacc.c:1646 */ - { (yyval.type) = type_new_encapsulated_union((yyvsp[-8].str), (yyvsp[-5].var), (yyvsp[-3].var), (yyvsp[-1].var_list)); } -#line 4939 "parser.tab.c" /* yacc.c:1646 */ - break; - - case 392: -#line 1145 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = MAKEVERSION((yyvsp[0].num), 0); } -#line 4945 "parser.tab.c" /* yacc.c:1646 */ +#line 4975 "parser.tab.c" /* yacc.c:1646 */ break; case 393: -#line 1146 "parser.y" /* yacc.c:1646 */ - { (yyval.num) = MAKEVERSION((yyvsp[-2].num), (yyvsp[0].num)); } -#line 4951 "parser.tab.c" /* yacc.c:1646 */ +#line 1163 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_nonencapsulated_union((yyvsp[-3].str), TRUE, (yyvsp[-1].var_list)); } +#line 4981 "parser.tab.c" /* yacc.c:1646 */ break; case 394: -#line 1147 "parser.y" /* yacc.c:1646 */ +#line 1166 "parser.y" /* yacc.c:1646 */ + { (yyval.type) = type_new_encapsulated_union((yyvsp[-8].str), (yyvsp[-5].var), (yyvsp[-3].var), (yyvsp[-1].var_list)); } +#line 4987 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 395: +#line 1170 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = MAKEVERSION((yyvsp[0].num), 0); } +#line 4993 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 396: +#line 1171 "parser.y" /* yacc.c:1646 */ + { (yyval.num) = MAKEVERSION((yyvsp[-2].num), (yyvsp[0].num)); } +#line 4999 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 397: +#line 1172 "parser.y" /* yacc.c:1646 */ { (yyval.num) = (yyvsp[0].num); } -#line 4957 "parser.tab.c" /* yacc.c:1646 */ +#line 5005 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 402: +#line 1185 "parser.y" /* yacc.c:1646 */ + { type_t *type = find_type_or_error((yyvsp[-1].str), 0); + type->attrs = append_attr_list(type->attrs, (yyvsp[-2].attr_list)); + } +#line 5013 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 403: +#line 1190 "parser.y" /* yacc.c:1646 */ + { type_t *iface = find_type_or_error2((yyvsp[-3].str), 0); + if (type_get_type(iface) != TYPE_INTERFACE) + error_loc("%s is not an interface\n", iface->name); + iface->attrs = append_attr_list(iface->attrs, (yyvsp[-5].attr_list)); + } +#line 5023 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 404: +#line 1197 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = NULL; } +#line 5029 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 405: +#line 1198 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = (yyvsp[-1].attr_list); } +#line 5035 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 406: +#line 1201 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = append_attr(NULL, (yyvsp[0].attr)); } +#line 5041 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 407: +#line 1202 "parser.y" /* yacc.c:1646 */ + { (yyval.attr_list) = append_attr((yyvsp[-2].attr_list), (yyvsp[0].attr)); } +#line 5047 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 408: +#line 1205 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_ENCODE); } +#line 5053 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 409: +#line 1206 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_DECODE); } +#line 5059 "parser.tab.c" /* yacc.c:1646 */ + break; + + case 410: +#line 1207 "parser.y" /* yacc.c:1646 */ + { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); } +#line 5065 "parser.tab.c" /* yacc.c:1646 */ break; -#line 4961 "parser.tab.c" /* yacc.c:1646 */ +#line 5069 "parser.tab.c" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -5185,7 +5293,7 @@ yyreturn: #endif return yyresult; } -#line 1150 "parser.y" /* yacc.c:1906 */ +#line 1209 "parser.y" /* yacc.c:1906 */ static void decl_builtin_basic(const char *name, enum type_basic_type type) @@ -5275,10 +5383,13 @@ static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_lis return new_list; } -static attr_list_t *dupattrs(const attr_list_t *list) +typedef int (*map_attrs_filter_t)(attr_list_t*,const attr_t*); + +static attr_list_t *map_attrs(const attr_list_t *list, map_attrs_filter_t filter) { attr_list_t *new_list; const attr_t *attr; + attr_t *new_attr; if (!list) return NULL; @@ -5286,7 +5397,8 @@ static attr_list_t *dupattrs(const attr_list_t *list) list_init( new_list ); LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry) { - attr_t *new_attr = xmalloc(sizeof(*new_attr)); + if (filter && !filter(new_list, attr)) continue; + new_attr = xmalloc(sizeof(*new_attr)); *new_attr = *attr; list_add_tail(new_list, &new_attr->entry); } @@ -5336,7 +5448,7 @@ static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t { attr_list_t *attrs; declspec->type = duptype(type, 1); - attrs = dupattrs(type->attrs); + attrs = map_attrs(type->attrs, NULL); declspec->type->attrs = append_attr_list(attrs, declspec->attrs); declspec->attrs = NULL; } @@ -5380,16 +5492,19 @@ static expr_list_t *append_expr(expr_list_t *list, expr_t *expr) return list; } -static array_dims_t *append_array(array_dims_t *list, expr_t *expr) +static type_t *append_array(type_t *chain, expr_t *expr) { - if (!expr) return list; - if (!list) - { - list = xmalloc( sizeof(*list) ); - list_init( list ); - } - list_add_tail( list, &expr->entry ); - return list; + type_t *array; + + if (!expr) + return chain; + + /* An array is always a reference pointer unless explicitly marked otherwise + * (regardless of what the default pointer attribute is). */ + array = type_new_array(NULL, NULL, FALSE, expr->is_const ? expr->cval : 0, + expr->is_const ? NULL : expr, NULL, FC_RP); + + return append_chain_type(chain, array); } static struct list type_pool = LIST_INIT(type_pool); @@ -5445,6 +5560,7 @@ static int is_allowed_range_type(const type_t *type) case TYPE_BASIC_INT64: case TYPE_BASIC_INT: case TYPE_BASIC_INT3264: + case TYPE_BASIC_LONG: case TYPE_BASIC_BYTE: case TYPE_BASIC_CHAR: case TYPE_BASIC_WCHAR: @@ -5462,16 +5578,32 @@ static int is_allowed_range_type(const type_t *type) } } -static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type) +static type_t *get_array_or_ptr_ref(type_t *type) { - type_t *ptrchain_type; - if (!ptrchain) - return type; - for (ptrchain_type = ptrchain; type_pointer_get_ref(ptrchain_type); ptrchain_type = type_pointer_get_ref(ptrchain_type)) - ; - assert(ptrchain_type->type_type == TYPE_POINTER); - ptrchain_type->details.pointer.ref = type; - return ptrchain; + if (is_ptr(type)) + return type_pointer_get_ref(type); + else if (is_array(type)) + return type_array_get_element(type); + return NULL; +} + +static type_t *append_chain_type(type_t *chain, type_t *type) +{ + type_t *chain_type; + + if (!chain) + return type; + for (chain_type = chain; get_array_or_ptr_ref(chain_type); chain_type = get_array_or_ptr_ref(chain_type)) + ; + + if (is_ptr(chain_type)) + chain_type->details.pointer.ref = type; + else if (is_array(chain_type)) + chain_type->details.array.elem = type; + else + assert(0); + + return chain; } static warning_list_t *append_warning(warning_list_t *list, int num) @@ -5495,10 +5627,8 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl var_t *v = decl->var; expr_list_t *sizes = get_attrp(attrs, ATTR_SIZEIS); expr_list_t *lengs = get_attrp(attrs, ATTR_LENGTHIS); - int sizeless; expr_t *dim; type_t **ptype; - array_dims_t *arr = decl ? decl->array : NULL; type_t *func_type = decl ? decl->func_type : NULL; type_t *type = decl_spec->type; @@ -5517,13 +5647,13 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl } /* add type onto the end of the pointers in pident->type */ - v->type = append_ptrchain_type(decl ? decl->type : NULL, type); + v->type = append_chain_type(decl ? decl->type : NULL, type); v->stgclass = decl_spec->stgclass; v->attrs = attrs; /* check for pointer attribute being applied to non-pointer, non-array * type */ - if (!arr) + if (!is_array(v->type)) { int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE); const type_t *ptr = NULL; @@ -5540,12 +5670,12 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl } if (is_ptr(ptr)) { - if (ptr_attr && ptr_attr != RPC_FC_UP && + if (ptr_attr && ptr_attr != FC_UP && type_get_type(type_pointer_get_ref(ptr)) == TYPE_INTERFACE) warning_loc_info(&v->loc_info, "%s: pointer attribute applied to interface " "pointer type has no effect\n", v->name); - if (!ptr_attr && top && (*pt)->details.pointer.def_fc != RPC_FC_RP) + if (!ptr_attr && top && (*pt)->details.pointer.def_fc != FC_RP) { /* FIXME: this is a horrible hack to cope with the issue that we * store an offset to the typeformat string in the type object, but @@ -5562,17 +5692,24 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl { type_t *t = type; - if (!is_ptr(v->type) && !arr) + if (!is_ptr(v->type) && !is_array(v->type)) error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n", v->name); - while (is_ptr(t)) - t = type_pointer_get_ref(t); + for (;;) + { + if (is_ptr(t)) + t = type_pointer_get_ref(t); + else if (is_array(t)) + t = type_array_get_element(t); + else + break; + } if (type_get_type(t) != TYPE_BASIC && - (get_basic_fc(t) != RPC_FC_CHAR && - get_basic_fc(t) != RPC_FC_BYTE && - get_basic_fc(t) != RPC_FC_WCHAR)) + (get_basic_fc(t) != FC_CHAR && + get_basic_fc(t) != FC_BYTE && + get_basic_fc(t) != FC_WCHAR)) { error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n", v->name); @@ -5589,36 +5726,6 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl error_loc("'%s': [range] attribute applied to non-integer type\n", v->name); - ptype = &v->type; - sizeless = FALSE; - if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry) - { - if (sizeless) - error_loc("%s: only the first array dimension can be unspecified\n", v->name); - - if (dim->is_const) - { - if (dim->cval <= 0) - error_loc("%s: array dimension must be positive\n", v->name); - - /* FIXME: should use a type_memsize that allows us to pass in a pointer size */ - if (0) - { - unsigned int size = type_memsize(v->type); - - if (0xffffffffu / size < dim->cval) - error_loc("%s: total array size is too large\n", v->name); - } - } - else - sizeless = TRUE; - - *ptype = type_new_array(NULL, *ptype, FALSE, - dim->is_const ? dim->cval : 0, - dim->is_const ? NULL : dim, NULL, - pointer_default); - } - ptype = &v->type; if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry) { @@ -5778,6 +5885,18 @@ var_t *make_var(char *name) return v; } +static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter) +{ + var_t *v = xmalloc(sizeof(var_t)); + v->name = name; + v->type = src->type; + v->attrs = map_attrs(src->attrs, attr_filter); + v->eval = src->eval; + v->stgclass = src->stgclass; + v->loc_info = src->loc_info; + return v; +} + static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d) { if (!d) return list; @@ -5795,7 +5914,6 @@ static declarator_t *make_declarator(var_t *var) d->var = var ? var : make_var(NULL); d->type = NULL; d->func_type = NULL; - d->array = NULL; d->bits = NULL; return d; } @@ -5803,7 +5921,7 @@ static declarator_t *make_declarator(var_t *var) static type_t *make_safearray(type_t *type) { return type_new_array(NULL, type_new_alias(type, "SAFEARRAY"), TRUE, 0, - NULL, NULL, RPC_FC_RP); + NULL, NULL, FC_RP); } static typelib_t *make_library(const char *name, const attr_list_t *attrs) @@ -6454,6 +6572,7 @@ static int is_allowed_conf_type(const type_t *type) case TYPE_BASIC_INT32: case TYPE_BASIC_INT64: case TYPE_BASIC_INT: + case TYPE_BASIC_LONG: case TYPE_BASIC_CHAR: case TYPE_BASIC_HYPER: case TYPE_BASIC_BYTE: @@ -6794,6 +6913,87 @@ static void check_functions(const type_t *iface, int is_inside_library) } } +static char *concat_str(const char *prefix, const char *str) +{ + char *ret = xmalloc(strlen(prefix) + strlen(str) + 1); + strcpy(ret, prefix); + strcat(ret, str); + return ret; +} + +static int async_iface_attrs(attr_list_t *attrs, const attr_t *attr) +{ + switch(attr->type) + { + case ATTR_UUID: + return 0; + case ATTR_ASYNCUUID: + append_attr(attrs, make_attrp(ATTR_UUID, attr->u.pval)); + return 0; + default: + return 1; + } +} + +static int arg_in_attrs(attr_list_t *attrs, const attr_t *attr) +{ + return attr->type != ATTR_OUT && attr->type != ATTR_RETVAL; +} + +static int arg_out_attrs(attr_list_t *attrs, const attr_t *attr) +{ + return attr->type != ATTR_IN; +} + +static void check_async_uuid(type_t *iface) +{ + statement_list_t *stmts = NULL; + statement_t *stmt; + type_t *async_iface; + type_t *inherit; + + if (!is_attr(iface->attrs, ATTR_ASYNCUUID)) return; + + inherit = iface->details.iface->inherit; + if (inherit && strcmp(inherit->name, "IUnknown")) + inherit = inherit->details.iface->async_iface; + if (!inherit) + error_loc("async_uuid applied to an interface with incompatible parent\n"); + + async_iface = get_type(TYPE_INTERFACE, concat_str("Async", iface->name), iface->namespace, 0); + async_iface->attrs = map_attrs(iface->attrs, async_iface_attrs); + + STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) + { + var_t *begin_func, *finish_func, *func = stmt->u.var, *arg; + var_list_t *begin_args = NULL, *finish_args = NULL, *args; + + args = func->type->details.function->args; + if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry) + { + if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT)) + begin_args = append_var(begin_args, copy_var(arg, strdup(arg->name), arg_in_attrs)); + if (is_attr(arg->attrs, ATTR_OUT)) + finish_args = append_var(finish_args, copy_var(arg, strdup(arg->name), arg_out_attrs)); + } + + begin_func = copy_var(func, concat_str("Begin_", func->name), NULL); + begin_func->type = type_new_function(begin_args); + begin_func->type->attrs = func->attrs; + begin_func->type->details.function->retval = func->type->details.function->retval; + stmts = append_statement(stmts, make_statement_declaration(begin_func)); + + finish_func = copy_var(func, concat_str("Finish_", func->name), NULL); + finish_func->type = type_new_function(finish_args); + finish_func->type->attrs = func->attrs; + finish_func->type->details.function->retval = func->type->details.function->retval; + stmts = append_statement(stmts, make_statement_declaration(finish_func)); + } + + type_interface_define(async_iface, inherit, stmts); + iface->details.iface->async_iface = async_iface->details.iface->async_iface = async_iface; +} + static void check_statements(const statement_list_t *stmts, int is_inside_library) { const statement_t *stmt; diff --git a/sdk/tools/widl/parser.tab.h b/sdk/tools/widl/parser.tab.h index 86600640f78..39cd683b177 100644 --- a/sdk/tools/widl/parser.tab.h +++ b/sdk/tools/widl/parser.tab.h @@ -30,8 +30,8 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -#ifndef YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED -# define YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED +#ifndef YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED +# define YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 @@ -56,179 +56,181 @@ extern int parser_debug; aSQSTRING = 266, aUUID = 267, aEOF = 268, - SHL = 269, - SHR = 270, - MEMBERPTR = 271, - EQUALITY = 272, - INEQUALITY = 273, - GREATEREQUAL = 274, - LESSEQUAL = 275, - LOGICALOR = 276, - LOGICALAND = 277, - ELLIPSIS = 278, - tAGGREGATABLE = 279, - tALLOCATE = 280, - tANNOTATION = 281, - tAPPOBJECT = 282, - tASYNC = 283, - tASYNCUUID = 284, - tAUTOHANDLE = 285, - tBINDABLE = 286, - tBOOLEAN = 287, - tBROADCAST = 288, - tBYTE = 289, - tBYTECOUNT = 290, - tCALLAS = 291, - tCALLBACK = 292, - tCASE = 293, - tCDECL = 294, - tCHAR = 295, - tCOCLASS = 296, - tCODE = 297, - tCOMMSTATUS = 298, - tCONST = 299, - tCONTEXTHANDLE = 300, - tCONTEXTHANDLENOSERIALIZE = 301, - tCONTEXTHANDLESERIALIZE = 302, - tCONTROL = 303, - tCPPQUOTE = 304, - tDECODE = 305, - tDEFAULT = 306, - tDEFAULTBIND = 307, - tDEFAULTCOLLELEM = 308, - tDEFAULTVALUE = 309, - tDEFAULTVTABLE = 310, - tDISABLECONSISTENCYCHECK = 311, - tDISPLAYBIND = 312, - tDISPINTERFACE = 313, - tDLLNAME = 314, - tDOUBLE = 315, - tDUAL = 316, - tENABLEALLOCATE = 317, - tENCODE = 318, - tENDPOINT = 319, - tENTRY = 320, - tENUM = 321, - tERRORSTATUST = 322, - tEXPLICITHANDLE = 323, - tEXTERN = 324, - tFALSE = 325, - tFASTCALL = 326, - tFAULTSTATUS = 327, - tFLOAT = 328, - tFORCEALLOCATE = 329, - tHANDLE = 330, - tHANDLET = 331, - tHELPCONTEXT = 332, - tHELPFILE = 333, - tHELPSTRING = 334, - tHELPSTRINGCONTEXT = 335, - tHELPSTRINGDLL = 336, - tHIDDEN = 337, - tHYPER = 338, - tID = 339, - tIDEMPOTENT = 340, - tIGNORE = 341, - tIIDIS = 342, - tIMMEDIATEBIND = 343, - tIMPLICITHANDLE = 344, - tIMPORT = 345, - tIMPORTLIB = 346, - tIN = 347, - tIN_LINE = 348, - tINLINE = 349, - tINPUTSYNC = 350, - tINT = 351, - tINT3264 = 352, - tINT64 = 353, - tINTERFACE = 354, - tLCID = 355, - tLENGTHIS = 356, - tLIBRARY = 357, - tLICENSED = 358, - tLOCAL = 359, - tLONG = 360, - tMAYBE = 361, - tMESSAGE = 362, - tMETHODS = 363, - tMODULE = 364, - tNAMESPACE = 365, - tNOCODE = 366, - tNONBROWSABLE = 367, - tNONCREATABLE = 368, - tNONEXTENSIBLE = 369, - tNOTIFY = 370, - tNOTIFYFLAG = 371, - tNULL = 372, - tOBJECT = 373, - tODL = 374, - tOLEAUTOMATION = 375, - tOPTIMIZE = 376, - tOPTIONAL = 377, - tOUT = 378, - tPARTIALIGNORE = 379, - tPASCAL = 380, - tPOINTERDEFAULT = 381, - tPRAGMA_WARNING = 382, - tPROGID = 383, - tPROPERTIES = 384, - tPROPGET = 385, - tPROPPUT = 386, - tPROPPUTREF = 387, - tPROXY = 388, - tPTR = 389, - tPUBLIC = 390, - tRANGE = 391, - tREADONLY = 392, - tREF = 393, - tREGISTER = 394, - tREPRESENTAS = 395, - tREQUESTEDIT = 396, - tRESTRICTED = 397, - tRETVAL = 398, - tSAFEARRAY = 399, - tSHORT = 400, - tSIGNED = 401, - tSIZEIS = 402, - tSIZEOF = 403, - tSMALL = 404, - tSOURCE = 405, - tSTATIC = 406, - tSTDCALL = 407, - tSTRICTCONTEXTHANDLE = 408, - tSTRING = 409, - tSTRUCT = 410, - tSWITCH = 411, - tSWITCHIS = 412, - tSWITCHTYPE = 413, - tTHREADING = 414, - tTRANSMITAS = 415, - tTRUE = 416, - tTYPEDEF = 417, - tUIDEFAULT = 418, - tUNION = 419, - tUNIQUE = 420, - tUNSIGNED = 421, - tUSESGETLASTERROR = 422, - tUSERMARSHAL = 423, - tUUID = 424, - tV1ENUM = 425, - tVARARG = 426, - tVERSION = 427, - tVIPROGID = 428, - tVOID = 429, - tWCHAR = 430, - tWIREMARSHAL = 431, - tAPARTMENT = 432, - tNEUTRAL = 433, - tSINGLE = 434, - tFREE = 435, - tBOTH = 436, - CAST = 437, - PPTR = 438, - POS = 439, - NEG = 440, - ADDRESSOF = 441 + aACF = 269, + SHL = 270, + SHR = 271, + MEMBERPTR = 272, + EQUALITY = 273, + INEQUALITY = 274, + GREATEREQUAL = 275, + LESSEQUAL = 276, + LOGICALOR = 277, + LOGICALAND = 278, + ELLIPSIS = 279, + tAGGREGATABLE = 280, + tALLOCATE = 281, + tANNOTATION = 282, + tAPPOBJECT = 283, + tASYNC = 284, + tASYNCUUID = 285, + tAUTOHANDLE = 286, + tBINDABLE = 287, + tBOOLEAN = 288, + tBROADCAST = 289, + tBYTE = 290, + tBYTECOUNT = 291, + tCALLAS = 292, + tCALLBACK = 293, + tCASE = 294, + tCDECL = 295, + tCHAR = 296, + tCOCLASS = 297, + tCODE = 298, + tCOMMSTATUS = 299, + tCONST = 300, + tCONTEXTHANDLE = 301, + tCONTEXTHANDLENOSERIALIZE = 302, + tCONTEXTHANDLESERIALIZE = 303, + tCONTROL = 304, + tCPPQUOTE = 305, + tDECODE = 306, + tDEFAULT = 307, + tDEFAULTBIND = 308, + tDEFAULTCOLLELEM = 309, + tDEFAULTVALUE = 310, + tDEFAULTVTABLE = 311, + tDISABLECONSISTENCYCHECK = 312, + tDISPLAYBIND = 313, + tDISPINTERFACE = 314, + tDLLNAME = 315, + tDOUBLE = 316, + tDUAL = 317, + tENABLEALLOCATE = 318, + tENCODE = 319, + tENDPOINT = 320, + tENTRY = 321, + tENUM = 322, + tERRORSTATUST = 323, + tEXPLICITHANDLE = 324, + tEXTERN = 325, + tFALSE = 326, + tFASTCALL = 327, + tFAULTSTATUS = 328, + tFLOAT = 329, + tFORCEALLOCATE = 330, + tHANDLE = 331, + tHANDLET = 332, + tHELPCONTEXT = 333, + tHELPFILE = 334, + tHELPSTRING = 335, + tHELPSTRINGCONTEXT = 336, + tHELPSTRINGDLL = 337, + tHIDDEN = 338, + tHYPER = 339, + tID = 340, + tIDEMPOTENT = 341, + tIGNORE = 342, + tIIDIS = 343, + tIMMEDIATEBIND = 344, + tIMPLICITHANDLE = 345, + tIMPORT = 346, + tIMPORTLIB = 347, + tIN = 348, + tIN_LINE = 349, + tINLINE = 350, + tINPUTSYNC = 351, + tINT = 352, + tINT32 = 353, + tINT3264 = 354, + tINT64 = 355, + tINTERFACE = 356, + tLCID = 357, + tLENGTHIS = 358, + tLIBRARY = 359, + tLICENSED = 360, + tLOCAL = 361, + tLONG = 362, + tMAYBE = 363, + tMESSAGE = 364, + tMETHODS = 365, + tMODULE = 366, + tNAMESPACE = 367, + tNOCODE = 368, + tNONBROWSABLE = 369, + tNONCREATABLE = 370, + tNONEXTENSIBLE = 371, + tNOTIFY = 372, + tNOTIFYFLAG = 373, + tNULL = 374, + tOBJECT = 375, + tODL = 376, + tOLEAUTOMATION = 377, + tOPTIMIZE = 378, + tOPTIONAL = 379, + tOUT = 380, + tPARTIALIGNORE = 381, + tPASCAL = 382, + tPOINTERDEFAULT = 383, + tPRAGMA_WARNING = 384, + tPROGID = 385, + tPROPERTIES = 386, + tPROPGET = 387, + tPROPPUT = 388, + tPROPPUTREF = 389, + tPROXY = 390, + tPTR = 391, + tPUBLIC = 392, + tRANGE = 393, + tREADONLY = 394, + tREF = 395, + tREGISTER = 396, + tREPRESENTAS = 397, + tREQUESTEDIT = 398, + tRESTRICTED = 399, + tRETVAL = 400, + tSAFEARRAY = 401, + tSHORT = 402, + tSIGNED = 403, + tSIZEIS = 404, + tSIZEOF = 405, + tSMALL = 406, + tSOURCE = 407, + tSTATIC = 408, + tSTDCALL = 409, + tSTRICTCONTEXTHANDLE = 410, + tSTRING = 411, + tSTRUCT = 412, + tSWITCH = 413, + tSWITCHIS = 414, + tSWITCHTYPE = 415, + tTHREADING = 416, + tTRANSMITAS = 417, + tTRUE = 418, + tTYPEDEF = 419, + tUIDEFAULT = 420, + tUNION = 421, + tUNIQUE = 422, + tUNSIGNED = 423, + tUSESGETLASTERROR = 424, + tUSERMARSHAL = 425, + tUUID = 426, + tV1ENUM = 427, + tVARARG = 428, + tVERSION = 429, + tVIPROGID = 430, + tVOID = 431, + tWCHAR = 432, + tWIREMARSHAL = 433, + tAPARTMENT = 434, + tNEUTRAL = 435, + tSINGLE = 436, + tFREE = 437, + tBOTH = 438, + CAST = 439, + PPTR = 440, + POS = 441, + NEG = 442, + ADDRESSOF = 443 }; #endif @@ -237,14 +239,13 @@ extern int parser_debug; typedef union YYSTYPE YYSTYPE; union YYSTYPE { -#line 138 "parser.y" /* yacc.c:1909 */ +#line 144 "parser.y" /* yacc.c:1909 */ attr_t *attr; attr_list_t *attr_list; str_list_t *str_list; expr_t *expr; expr_list_t *expr_list; - array_dims_t *array_dims; type_t *type; var_t *var; var_list_t *var_list; @@ -266,7 +267,7 @@ union YYSTYPE struct _decl_spec_t *declspec; enum storage_class stgclass; -#line 270 "parser.tab.h" /* yacc.c:1909 */ +#line 271 "parser.tab.h" /* yacc.c:1909 */ }; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -277,4 +278,4 @@ extern YYSTYPE parser_lval; int parser_parse (void); -#endif /* !YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ +#endif /* !YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ diff --git a/sdk/tools/widl/parser.y b/sdk/tools/widl/parser.y index c895a876fcd..7b06aa6892d 100644 --- a/sdk/tools/widl/parser.y +++ b/sdk/tools/widl/parser.y @@ -38,7 +38,7 @@ #include "expr.h" #include "typetree.h" -static unsigned char pointer_default = RPC_FC_UP; +static unsigned char pointer_default = FC_UP; typedef struct list typelist_t; struct typenode { @@ -72,7 +72,7 @@ static attr_t *make_attr(enum attr_type type); static attr_t *make_attrv(enum attr_type type, unsigned int val); static attr_t *make_attrp(enum attr_type type, void *val); static expr_list_t *append_expr(expr_list_t *list, expr_t *expr); -static array_dims_t *append_array(array_dims_t *list, expr_t *expr); +static type_t *append_array(type_t *chain, expr_t *expr); static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top); static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls); static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface); @@ -82,7 +82,7 @@ static declarator_list_t *append_declarator(declarator_list_t *list, declarator_ static declarator_t *make_declarator(var_t *var); static type_t *make_safearray(type_t *type); static typelib_t *make_library(const char *name, const attr_list_t *attrs); -static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type); +static type_t *append_chain_type(type_t *chain, type_t *type); static warning_list_t *append_warning(warning_list_t *, int); static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs); @@ -113,6 +113,8 @@ const char *get_attr_display_name(enum attr_type type); static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func); static void check_def(const type_t *t); +static void check_async_uuid(type_t *iface); + static statement_t *make_statement(enum statement_type type); static statement_t *make_statement_type_decl(type_t *type); static statement_t *make_statement_reference(type_t *type); @@ -134,6 +136,10 @@ static struct namespace global_namespace = { static struct namespace *current_namespace = &global_namespace; +#ifndef __REACTOS__ +static typelib_t *current_typelib; +#endif + %} %union { attr_t *attr; @@ -141,7 +147,6 @@ static struct namespace *current_namespace = &global_namespace; str_list_t *str_list; expr_t *expr; expr_list_t *expr_list; - array_dims_t *array_dims; type_t *type; var_t *var; var_list_t *var_list; @@ -170,7 +175,7 @@ static struct namespace *current_namespace = &global_namespace; %token aDOUBLE %token aSTRING aWSTRING aSQSTRING %token aUUID -%token aEOF +%token aEOF aACF %token SHL SHR %token MEMBERPTR %token EQUALITY INEQUALITY @@ -207,7 +212,7 @@ static struct namespace *current_namespace = &global_namespace; %token tIMPORT tIMPORTLIB %token tIN tIN_LINE tINLINE %token tINPUTSYNC -%token tINT tINT3264 tINT64 +%token tINT tINT32 tINT3264 tINT64 %token tINTERFACE %token tLCID %token tLENGTHIS tLIBRARY @@ -263,8 +268,9 @@ static struct namespace *current_namespace = &global_namespace; %token tWCHAR tWIREMARSHAL %token tAPARTMENT tNEUTRAL tSINGLE tFREE tBOTH -%type attribute type_qualifier function_specifier +%type attribute type_qualifier function_specifier acf_attribute %type m_attributes attributes attrib_list m_type_qual_list +%type acf_attributes acf_attribute_list %type str_list %type m_expr expr expr_const expr_int_const array m_bitfield %type m_exprs /* exprs expr_list */ expr_list_int_const @@ -318,7 +324,7 @@ static struct namespace *current_namespace = &global_namespace; %% -input: gbl_statements { fix_incomplete(); +input: gbl_statements m_acf { fix_incomplete(); check_statements($1, FALSE); check_all_user_types($1); write_header($1); @@ -327,11 +333,16 @@ input: gbl_statements { fix_incomplete(); write_client($1); write_server($1); write_regscript($1); +#ifndef __REACTOS__ + write_typelib_regscript($1); +#endif write_dlldata($1); write_local_stubs($1); } ; +m_acf: /* empty */ | aACF acf_statements + gbl_statements: { $$ = NULL; } | gbl_statements namespacedef '{' { push_namespace($2); } gbl_statements '}' { pop_namespace($2); $$ = append_statements($1, $5); } @@ -425,21 +436,33 @@ import: import_start imp_statements aEOF { $$ = $1->name; ; importlib: tIMPORTLIB '(' aSTRING ')' +/* ifdef __REACTOS__ */ semicolon_opt { $$ = $3; if(!parse_only) add_importlib($3); } +/* else + semicolon_opt { $$ = $3; if(!parse_only) add_importlib($3, current_typelib); } +*/ ; libraryhdr: tLIBRARY aIDENTIFIER { $$ = $2; } | tLIBRARY aKNOWNTYPE { $$ = $2; } ; library_start: attributes libraryhdr '{' { $$ = make_library($2, check_library_attrs($2, $1)); +/* ifdef __REACTOS__ */ if (!parse_only) start_typelib($$); +/* else + if (!parse_only && do_typelib) current_typelib = $$; +*/ } ; librarydef: library_start imp_statements '}' +/* ifdef __REACTOS__ */ semicolon_opt { $$ = $1; $$->stmts = $2; if (!parse_only) end_typelib(); } +/* else + semicolon_opt { $$ = $1; $$->stmts = $2; } +*/ ; m_args: { $$ = NULL; } @@ -468,8 +491,8 @@ arg: attributes decl_spec m_any_declarator { if ($2->stgclass != STG_NONE && $ ; array: '[' expr ']' { $$ = $2; - if (!$$->is_const) - error_loc("array dimension is not an integer constant\n"); + if (!$$->is_const || $$->cval <= 0) + error_loc("array dimension is not a positive integer constant\n"); } | '[' '*' ']' { $$ = make_expr(EXPR_VOID); } | '[' ']' { $$ = make_expr(EXPR_VOID); } @@ -816,10 +839,11 @@ m_int: int_std: tINT { $$ = type_new_int(TYPE_BASIC_INT, 0); } | tSHORT m_int { $$ = type_new_int(TYPE_BASIC_INT16, 0); } | tSMALL { $$ = type_new_int(TYPE_BASIC_INT8, 0); } - | tLONG m_int { $$ = type_new_int(TYPE_BASIC_INT32, 0); } + | tLONG m_int { $$ = type_new_int(TYPE_BASIC_LONG, 0); } | tHYPER m_int { $$ = type_new_int(TYPE_BASIC_HYPER, 0); } | tINT64 { $$ = type_new_int(TYPE_BASIC_INT64, 0); } | tCHAR { $$ = type_new_int(TYPE_BASIC_CHAR, 0); } + | tINT32 { $$ = type_new_int(TYPE_BASIC_INT32, 0); } | tINT3264 { $$ = type_new_int(TYPE_BASIC_INT3264, 0); } ; @@ -909,6 +933,7 @@ interfacedef: interfacehdr inherit if($$ == $2) error_loc("Interface can't inherit from itself\n"); type_interface_define($$, $2, $4); + check_async_uuid($$); pointer_default = $1.old_pointer_default; } /* MIDL is able to import the definition of a base class from inside the @@ -977,7 +1002,7 @@ decl_spec_no_type: declarator: '*' m_type_qual_list declarator %prec PPTR - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } | callconv declarator { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1)); else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } | direct_declarator @@ -986,9 +1011,9 @@ declarator: direct_declarator: ident { $$ = make_declarator($1); } | '(' declarator ')' { $$ = $2; } - | direct_declarator array { $$ = $1; $$->array = append_array($$->array, $2); } + | direct_declarator array { $$ = $1; $$->type = append_array($$->type, $2); } | direct_declarator '(' m_args ')' { $$ = $1; - $$->func_type = append_ptrchain_type($$->type, type_new_function($3)); + $$->func_type = append_chain_type($$->type, type_new_function($3)); $$->type = NULL; } ; @@ -996,7 +1021,7 @@ direct_declarator: /* abstract declarator */ abstract_declarator: '*' m_type_qual_list m_abstract_declarator %prec PPTR - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } | callconv m_abstract_declarator { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1)); else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } | abstract_direct_declarator @@ -1005,7 +1030,7 @@ abstract_declarator: /* abstract declarator without accepting direct declarator */ abstract_declarator_no_direct: '*' m_type_qual_list m_any_declarator %prec PPTR - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } | callconv m_any_declarator { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1)); else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } ; @@ -1018,16 +1043,16 @@ m_abstract_declarator: { $$ = make_declarator(NULL); } /* abstract direct declarator */ abstract_direct_declarator: '(' abstract_declarator_no_direct ')' { $$ = $2; } - | abstract_direct_declarator array { $$ = $1; $$->array = append_array($$->array, $2); } - | array { $$ = make_declarator(NULL); $$->array = append_array($$->array, $1); } + | abstract_direct_declarator array { $$ = $1; $$->type = append_array($$->type, $2); } + | array { $$ = make_declarator(NULL); $$->type = append_array($$->type, $1); } | '(' m_args ')' { $$ = make_declarator(NULL); - $$->func_type = append_ptrchain_type($$->type, type_new_function($2)); + $$->func_type = append_chain_type($$->type, type_new_function($2)); $$->type = NULL; } | abstract_direct_declarator '(' m_args ')' { $$ = $1; - $$->func_type = append_ptrchain_type($$->type, type_new_function($3)); + $$->func_type = append_chain_type($$->type, type_new_function($3)); $$->type = NULL; } ; @@ -1035,7 +1060,7 @@ abstract_direct_declarator: /* abstract or non-abstract declarator */ any_declarator: '*' m_type_qual_list m_any_declarator %prec PPTR - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } | callconv m_any_declarator { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } | any_direct_declarator ; @@ -1043,7 +1068,7 @@ any_declarator: /* abstract or non-abstract declarator without accepting direct declarator */ any_declarator_no_direct: '*' m_type_qual_list m_any_declarator %prec PPTR - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } | callconv m_any_declarator { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } ; @@ -1058,16 +1083,16 @@ m_any_declarator: { $$ = make_declarator(NULL); } any_direct_declarator: ident { $$ = make_declarator($1); } | '(' any_declarator_no_direct ')' { $$ = $2; } - | any_direct_declarator array { $$ = $1; $$->array = append_array($$->array, $2); } - | array { $$ = make_declarator(NULL); $$->array = append_array($$->array, $1); } + | any_direct_declarator array { $$ = $1; $$->type = append_array($$->type, $2); } + | array { $$ = make_declarator(NULL); $$->type = append_array($$->type, $1); } | '(' m_args ')' { $$ = make_declarator(NULL); - $$->func_type = append_ptrchain_type($$->type, type_new_function($2)); + $$->func_type = append_chain_type($$->type, type_new_function($2)); $$->type = NULL; } | any_direct_declarator '(' m_args ')' { $$ = $1; - $$->func_type = append_ptrchain_type($$->type, type_new_function($3)); + $$->func_type = append_chain_type($$->type, type_new_function($3)); $$->type = NULL; } ; @@ -1107,9 +1132,9 @@ threading_type: ; pointer_type: - tREF { $$ = RPC_FC_RP; } - | tUNIQUE { $$ = RPC_FC_UP; } - | tPTR { $$ = RPC_FC_FP; } + tREF { $$ = FC_RP; } + | tUNIQUE { $$ = FC_UP; } + | tPTR { $$ = FC_FP; } ; structdef: tSTRUCT t_ident '{' fields '}' { $$ = type_new_struct($2, current_namespace, TRUE, $4); } @@ -1147,6 +1172,40 @@ version: | aHEXNUM { $$ = $1; } ; +acf_statements + : /* empty */ + | acf_interface acf_statements + +acf_int_statements + : /* empty */ + | acf_int_statement acf_int_statements + +acf_int_statement + : tTYPEDEF acf_attributes aKNOWNTYPE ';' + { type_t *type = find_type_or_error($3, 0); + type->attrs = append_attr_list(type->attrs, $2); + } +acf_interface + : acf_attributes tINTERFACE aKNOWNTYPE '{' acf_int_statements '}' + { type_t *iface = find_type_or_error2($3, 0); + if (type_get_type(iface) != TYPE_INTERFACE) + error_loc("%s is not an interface\n", iface->name); + iface->attrs = append_attr_list(iface->attrs, $1); + } + +acf_attributes + : /* empty */ { $$ = NULL; }; + | '[' acf_attribute_list ']' { $$ = $2; }; + +acf_attribute_list + : acf_attribute { $$ = append_attr(NULL, $1); } + | acf_attribute_list ',' acf_attribute { $$ = append_attr($1, $3); } + +acf_attribute + : tENCODE { $$ = make_attr(ATTR_ENCODE); } + | tDECODE { $$ = make_attr(ATTR_DECODE); } + | tEXPLICITHANDLE { $$ = make_attr(ATTR_EXPLICIT_HANDLE); } + %% static void decl_builtin_basic(const char *name, enum type_basic_type type) @@ -1236,10 +1295,13 @@ static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_lis return new_list; } -static attr_list_t *dupattrs(const attr_list_t *list) +typedef int (*map_attrs_filter_t)(attr_list_t*,const attr_t*); + +static attr_list_t *map_attrs(const attr_list_t *list, map_attrs_filter_t filter) { attr_list_t *new_list; const attr_t *attr; + attr_t *new_attr; if (!list) return NULL; @@ -1247,7 +1309,8 @@ static attr_list_t *dupattrs(const attr_list_t *list) list_init( new_list ); LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry) { - attr_t *new_attr = xmalloc(sizeof(*new_attr)); + if (filter && !filter(new_list, attr)) continue; + new_attr = xmalloc(sizeof(*new_attr)); *new_attr = *attr; list_add_tail(new_list, &new_attr->entry); } @@ -1297,7 +1360,7 @@ static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t { attr_list_t *attrs; declspec->type = duptype(type, 1); - attrs = dupattrs(type->attrs); + attrs = map_attrs(type->attrs, NULL); declspec->type->attrs = append_attr_list(attrs, declspec->attrs); declspec->attrs = NULL; } @@ -1341,16 +1404,19 @@ static expr_list_t *append_expr(expr_list_t *list, expr_t *expr) return list; } -static array_dims_t *append_array(array_dims_t *list, expr_t *expr) +static type_t *append_array(type_t *chain, expr_t *expr) { - if (!expr) return list; - if (!list) - { - list = xmalloc( sizeof(*list) ); - list_init( list ); - } - list_add_tail( list, &expr->entry ); - return list; + type_t *array; + + if (!expr) + return chain; + + /* An array is always a reference pointer unless explicitly marked otherwise + * (regardless of what the default pointer attribute is). */ + array = type_new_array(NULL, NULL, FALSE, expr->is_const ? expr->cval : 0, + expr->is_const ? NULL : expr, NULL, FC_RP); + + return append_chain_type(chain, array); } static struct list type_pool = LIST_INIT(type_pool); @@ -1406,6 +1472,7 @@ static int is_allowed_range_type(const type_t *type) case TYPE_BASIC_INT64: case TYPE_BASIC_INT: case TYPE_BASIC_INT3264: + case TYPE_BASIC_LONG: case TYPE_BASIC_BYTE: case TYPE_BASIC_CHAR: case TYPE_BASIC_WCHAR: @@ -1423,16 +1490,32 @@ static int is_allowed_range_type(const type_t *type) } } -static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type) +static type_t *get_array_or_ptr_ref(type_t *type) { - type_t *ptrchain_type; - if (!ptrchain) - return type; - for (ptrchain_type = ptrchain; type_pointer_get_ref(ptrchain_type); ptrchain_type = type_pointer_get_ref(ptrchain_type)) - ; - assert(ptrchain_type->type_type == TYPE_POINTER); - ptrchain_type->details.pointer.ref = type; - return ptrchain; + if (is_ptr(type)) + return type_pointer_get_ref(type); + else if (is_array(type)) + return type_array_get_element(type); + return NULL; +} + +static type_t *append_chain_type(type_t *chain, type_t *type) +{ + type_t *chain_type; + + if (!chain) + return type; + for (chain_type = chain; get_array_or_ptr_ref(chain_type); chain_type = get_array_or_ptr_ref(chain_type)) + ; + + if (is_ptr(chain_type)) + chain_type->details.pointer.ref = type; + else if (is_array(chain_type)) + chain_type->details.array.elem = type; + else + assert(0); + + return chain; } static warning_list_t *append_warning(warning_list_t *list, int num) @@ -1456,10 +1539,8 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl var_t *v = decl->var; expr_list_t *sizes = get_attrp(attrs, ATTR_SIZEIS); expr_list_t *lengs = get_attrp(attrs, ATTR_LENGTHIS); - int sizeless; expr_t *dim; type_t **ptype; - array_dims_t *arr = decl ? decl->array : NULL; type_t *func_type = decl ? decl->func_type : NULL; type_t *type = decl_spec->type; @@ -1478,13 +1559,13 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl } /* add type onto the end of the pointers in pident->type */ - v->type = append_ptrchain_type(decl ? decl->type : NULL, type); + v->type = append_chain_type(decl ? decl->type : NULL, type); v->stgclass = decl_spec->stgclass; v->attrs = attrs; /* check for pointer attribute being applied to non-pointer, non-array * type */ - if (!arr) + if (!is_array(v->type)) { int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE); const type_t *ptr = NULL; @@ -1501,12 +1582,12 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl } if (is_ptr(ptr)) { - if (ptr_attr && ptr_attr != RPC_FC_UP && + if (ptr_attr && ptr_attr != FC_UP && type_get_type(type_pointer_get_ref(ptr)) == TYPE_INTERFACE) warning_loc_info(&v->loc_info, "%s: pointer attribute applied to interface " "pointer type has no effect\n", v->name); - if (!ptr_attr && top && (*pt)->details.pointer.def_fc != RPC_FC_RP) + if (!ptr_attr && top && (*pt)->details.pointer.def_fc != FC_RP) { /* FIXME: this is a horrible hack to cope with the issue that we * store an offset to the typeformat string in the type object, but @@ -1523,17 +1604,24 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl { type_t *t = type; - if (!is_ptr(v->type) && !arr) + if (!is_ptr(v->type) && !is_array(v->type)) error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n", v->name); - while (is_ptr(t)) - t = type_pointer_get_ref(t); + for (;;) + { + if (is_ptr(t)) + t = type_pointer_get_ref(t); + else if (is_array(t)) + t = type_array_get_element(t); + else + break; + } if (type_get_type(t) != TYPE_BASIC && - (get_basic_fc(t) != RPC_FC_CHAR && - get_basic_fc(t) != RPC_FC_BYTE && - get_basic_fc(t) != RPC_FC_WCHAR)) + (get_basic_fc(t) != FC_CHAR && + get_basic_fc(t) != FC_BYTE && + get_basic_fc(t) != FC_WCHAR)) { error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n", v->name); @@ -1550,36 +1638,6 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl error_loc("'%s': [range] attribute applied to non-integer type\n", v->name); - ptype = &v->type; - sizeless = FALSE; - if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry) - { - if (sizeless) - error_loc("%s: only the first array dimension can be unspecified\n", v->name); - - if (dim->is_const) - { - if (dim->cval <= 0) - error_loc("%s: array dimension must be positive\n", v->name); - - /* FIXME: should use a type_memsize that allows us to pass in a pointer size */ - if (0) - { - unsigned int size = type_memsize(v->type); - - if (0xffffffffu / size < dim->cval) - error_loc("%s: total array size is too large\n", v->name); - } - } - else - sizeless = TRUE; - - *ptype = type_new_array(NULL, *ptype, FALSE, - dim->is_const ? dim->cval : 0, - dim->is_const ? NULL : dim, NULL, - pointer_default); - } - ptype = &v->type; if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry) { @@ -1739,6 +1797,18 @@ var_t *make_var(char *name) return v; } +static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter) +{ + var_t *v = xmalloc(sizeof(var_t)); + v->name = name; + v->type = src->type; + v->attrs = map_attrs(src->attrs, attr_filter); + v->eval = src->eval; + v->stgclass = src->stgclass; + v->loc_info = src->loc_info; + return v; +} + static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d) { if (!d) return list; @@ -1756,7 +1826,6 @@ static declarator_t *make_declarator(var_t *var) d->var = var ? var : make_var(NULL); d->type = NULL; d->func_type = NULL; - d->array = NULL; d->bits = NULL; return d; } @@ -1764,7 +1833,7 @@ static declarator_t *make_declarator(var_t *var) static type_t *make_safearray(type_t *type) { return type_new_array(NULL, type_new_alias(type, "SAFEARRAY"), TRUE, 0, - NULL, NULL, RPC_FC_RP); + NULL, NULL, FC_RP); } static typelib_t *make_library(const char *name, const attr_list_t *attrs) @@ -2415,6 +2484,7 @@ static int is_allowed_conf_type(const type_t *type) case TYPE_BASIC_INT32: case TYPE_BASIC_INT64: case TYPE_BASIC_INT: + case TYPE_BASIC_LONG: case TYPE_BASIC_CHAR: case TYPE_BASIC_HYPER: case TYPE_BASIC_BYTE: @@ -2755,6 +2825,87 @@ static void check_functions(const type_t *iface, int is_inside_library) } } +static char *concat_str(const char *prefix, const char *str) +{ + char *ret = xmalloc(strlen(prefix) + strlen(str) + 1); + strcpy(ret, prefix); + strcat(ret, str); + return ret; +} + +static int async_iface_attrs(attr_list_t *attrs, const attr_t *attr) +{ + switch(attr->type) + { + case ATTR_UUID: + return 0; + case ATTR_ASYNCUUID: + append_attr(attrs, make_attrp(ATTR_UUID, attr->u.pval)); + return 0; + default: + return 1; + } +} + +static int arg_in_attrs(attr_list_t *attrs, const attr_t *attr) +{ + return attr->type != ATTR_OUT && attr->type != ATTR_RETVAL; +} + +static int arg_out_attrs(attr_list_t *attrs, const attr_t *attr) +{ + return attr->type != ATTR_IN; +} + +static void check_async_uuid(type_t *iface) +{ + statement_list_t *stmts = NULL; + statement_t *stmt; + type_t *async_iface; + type_t *inherit; + + if (!is_attr(iface->attrs, ATTR_ASYNCUUID)) return; + + inherit = iface->details.iface->inherit; + if (inherit && strcmp(inherit->name, "IUnknown")) + inherit = inherit->details.iface->async_iface; + if (!inherit) + error_loc("async_uuid applied to an interface with incompatible parent\n"); + + async_iface = get_type(TYPE_INTERFACE, concat_str("Async", iface->name), iface->namespace, 0); + async_iface->attrs = map_attrs(iface->attrs, async_iface_attrs); + + STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) + { + var_t *begin_func, *finish_func, *func = stmt->u.var, *arg; + var_list_t *begin_args = NULL, *finish_args = NULL, *args; + + args = func->type->details.function->args; + if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry) + { + if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT)) + begin_args = append_var(begin_args, copy_var(arg, strdup(arg->name), arg_in_attrs)); + if (is_attr(arg->attrs, ATTR_OUT)) + finish_args = append_var(finish_args, copy_var(arg, strdup(arg->name), arg_out_attrs)); + } + + begin_func = copy_var(func, concat_str("Begin_", func->name), NULL); + begin_func->type = type_new_function(begin_args); + begin_func->type->attrs = func->attrs; + begin_func->type->details.function->retval = func->type->details.function->retval; + stmts = append_statement(stmts, make_statement_declaration(begin_func)); + + finish_func = copy_var(func, concat_str("Finish_", func->name), NULL); + finish_func->type = type_new_function(finish_args); + finish_func->type->attrs = func->attrs; + finish_func->type->details.function->retval = func->type->details.function->retval; + stmts = append_statement(stmts, make_statement_declaration(finish_func)); + } + + type_interface_define(async_iface, inherit, stmts); + iface->details.iface->async_iface = async_iface->details.iface->async_iface = async_iface; +} + static void check_statements(const statement_list_t *stmts, int is_inside_library) { const statement_t *stmt; diff --git a/sdk/tools/widl/parser.yy.c b/sdk/tools/widl/parser.yy.c index 1502508b87f..4ddd9df5b64 100644 --- a/sdk/tools/widl/parser.yy.c +++ b/sdk/tools/widl/parser.yy.c @@ -764,6 +764,8 @@ static int cbufalloc = 0; static int kw_token(const char *kw); static int attr_token(const char *kw); +static void switch_to_acf(void); + static warning_list_t *disabled_warnings = NULL; #define MAX_IMPORT_DEPTH 20 @@ -813,7 +815,7 @@ UUID *parse_uuid(const char *u) * The flexer starts here ************************************************************************** */ -#line 817 "parser.yy.c" +#line 819 "parser.yy.c" #define INITIAL 0 #define QUOTE 1 @@ -1010,9 +1012,9 @@ YY_DECL register char *yy_cp, *yy_bp; register int yy_act; -#line 130 "parser.l" +#line 132 "parser.l" -#line 1016 "parser.yy.c" +#line 1018 "parser.yy.c" if ( !(yy_init) ) { @@ -1094,17 +1096,17 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 131 "parser.l" +#line 133 "parser.l" yy_push_state(PP_PRAGMA); YY_BREAK case 2: YY_RULE_SETUP -#line 132 "parser.l" +#line 134 "parser.l" yy_push_state(PP_LINE); YY_BREAK case 3: YY_RULE_SETUP -#line 133 "parser.l" +#line 135 "parser.l" { int lineno; char *cptr, *fname; @@ -1126,12 +1128,12 @@ YY_RULE_SETUP YY_BREAK case 4: YY_RULE_SETUP -#line 151 "parser.l" +#line 153 "parser.l" yyless(9); yy_pop_state(); return tCPPQUOTE; YY_BREAK case 5: YY_RULE_SETUP -#line 152 "parser.l" +#line 154 "parser.l" { if(import_stack_ptr) { if(!winrt_mode) @@ -1151,22 +1153,22 @@ YY_RULE_SETUP YY_BREAK case 6: YY_RULE_SETUP -#line 168 "parser.l" +#line 170 "parser.l" parser_lval.str = xstrdup(parser_text); yy_pop_state(); return aPRAGMA; YY_BREAK case 7: YY_RULE_SETUP -#line 169 "parser.l" +#line 171 "parser.l" return tPRAGMA_WARNING; YY_BREAK case 8: YY_RULE_SETUP -#line 170 "parser.l" +#line 172 "parser.l" yy_push_state(QUOTE); cbufidx = 0; YY_BREAK case 9: YY_RULE_SETUP -#line 171 "parser.l" +#line 173 "parser.l" { yy_pop_state(); parser_lval.str = get_buffered_cstring(); @@ -1175,12 +1177,12 @@ YY_RULE_SETUP YY_BREAK case 10: YY_RULE_SETUP -#line 176 "parser.l" +#line 178 "parser.l" yy_push_state(WSTRQUOTE); cbufidx = 0; YY_BREAK case 11: YY_RULE_SETUP -#line 177 "parser.l" +#line 179 "parser.l" { yy_pop_state(); parser_lval.str = get_buffered_cstring(); @@ -1189,12 +1191,12 @@ YY_RULE_SETUP YY_BREAK case 12: YY_RULE_SETUP -#line 182 "parser.l" +#line 184 "parser.l" yy_push_state(SQUOTE); cbufidx = 0; YY_BREAK case 13: YY_RULE_SETUP -#line 183 "parser.l" +#line 185 "parser.l" { yy_pop_state(); parser_lval.str = get_buffered_cstring(); @@ -1202,45 +1204,45 @@ YY_RULE_SETUP } YY_BREAK case 14: -#line 189 "parser.l" +#line 191 "parser.l" case 15: YY_RULE_SETUP -#line 189 "parser.l" +#line 191 "parser.l" addcchar(parser_text[1]); YY_BREAK case 16: YY_RULE_SETUP -#line 190 "parser.l" +#line 192 "parser.l" addcchar(parser_text[1]); YY_BREAK case 17: YY_RULE_SETUP -#line 191 "parser.l" +#line 193 "parser.l" addcchar('\\'); addcchar(parser_text[1]); YY_BREAK case 18: YY_RULE_SETUP -#line 192 "parser.l" +#line 194 "parser.l" addcchar(parser_text[0]); YY_BREAK case 19: YY_RULE_SETUP -#line 193 "parser.l" +#line 195 "parser.l" yy_push_state(ATTR); return '['; YY_BREAK case 20: YY_RULE_SETUP -#line 194 "parser.l" +#line 196 "parser.l" yy_pop_state(); return ']'; YY_BREAK case 21: YY_RULE_SETUP -#line 195 "parser.l" +#line 197 "parser.l" return attr_token(parser_text); YY_BREAK case 22: YY_RULE_SETUP -#line 196 "parser.l" +#line 198 "parser.l" { parser_lval.uuid = parse_uuid(parser_text); return aUUID; @@ -1248,7 +1250,7 @@ YY_RULE_SETUP YY_BREAK case 23: YY_RULE_SETUP -#line 200 "parser.l" +#line 202 "parser.l" { parser_lval.num = xstrtoul(parser_text, NULL, 0); return aHEXNUM; @@ -1256,7 +1258,7 @@ YY_RULE_SETUP YY_BREAK case 24: YY_RULE_SETUP -#line 204 "parser.l" +#line 206 "parser.l" { parser_lval.num = xstrtoul(parser_text, NULL, 0); return aNUM; @@ -1264,7 +1266,7 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 208 "parser.l" +#line 210 "parser.l" { parser_lval.dbl = strtod(parser_text, NULL); return aDOUBLE; @@ -1275,78 +1277,78 @@ case 26: (yy_c_buf_p) = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up parser_text again */ YY_RULE_SETUP -#line 212 "parser.l" +#line 214 "parser.l" return tSAFEARRAY; YY_BREAK case 27: YY_RULE_SETUP -#line 213 "parser.l" +#line 215 "parser.l" return kw_token(parser_text); YY_BREAK case 28: /* rule 28 can match eol */ YY_RULE_SETUP -#line 214 "parser.l" +#line 216 "parser.l" line_number++; YY_BREAK case 29: YY_RULE_SETUP -#line 215 "parser.l" +#line 217 "parser.l" YY_BREAK case 30: YY_RULE_SETUP -#line 216 "parser.l" +#line 218 "parser.l" return SHL; YY_BREAK case 31: YY_RULE_SETUP -#line 217 "parser.l" +#line 219 "parser.l" return SHR; YY_BREAK case 32: YY_RULE_SETUP -#line 218 "parser.l" +#line 220 "parser.l" return MEMBERPTR; YY_BREAK case 33: YY_RULE_SETUP -#line 219 "parser.l" +#line 221 "parser.l" return EQUALITY; YY_BREAK case 34: YY_RULE_SETUP -#line 220 "parser.l" +#line 222 "parser.l" return INEQUALITY; YY_BREAK case 35: YY_RULE_SETUP -#line 221 "parser.l" +#line 223 "parser.l" return GREATEREQUAL; YY_BREAK case 36: YY_RULE_SETUP -#line 222 "parser.l" +#line 224 "parser.l" return LESSEQUAL; YY_BREAK case 37: YY_RULE_SETUP -#line 223 "parser.l" +#line 225 "parser.l" return LOGICALOR; YY_BREAK case 38: YY_RULE_SETUP -#line 224 "parser.l" +#line 226 "parser.l" return LOGICALAND; YY_BREAK case 39: YY_RULE_SETUP -#line 225 "parser.l" +#line 227 "parser.l" return ELLIPSIS; YY_BREAK case 40: YY_RULE_SETUP -#line 226 "parser.l" +#line 228 "parser.l" return parser_text[0]; YY_BREAK case YY_STATE_EOF(INITIAL): @@ -1356,19 +1358,24 @@ case YY_STATE_EOF(ATTR): case YY_STATE_EOF(PP_LINE): case YY_STATE_EOF(PP_PRAGMA): case YY_STATE_EOF(SQUOTE): -#line 227 "parser.l" +#line 229 "parser.l" { - if (import_stack_ptr) - return aEOF; - else yyterminate(); + if (import_stack_ptr) + return aEOF; + if (acf_name) + { + switch_to_acf(); + return aACF; + } + yyterminate(); } YY_BREAK case 41: YY_RULE_SETUP -#line 232 "parser.l" +#line 239 "parser.l" ECHO; YY_BREAK -#line 1372 "parser.yy.c" +#line 1379 "parser.yy.c" case YY_END_OF_BUFFER: { @@ -2367,7 +2374,7 @@ void parser_free (void * ptr ) #define YYTABLES_NAME "yytables" -#line 231 "parser.l" +#line 238 "parser.l" @@ -2390,6 +2397,7 @@ static const struct keyword keywords[] = { {"TRUE", tTRUE}, {"__cdecl", tCDECL}, {"__fastcall", tFASTCALL}, + {"__int32", tINT32}, {"__int3264", tINT3264}, {"__int64", tINT64}, {"__pascal", tPASCAL}, @@ -2702,6 +2710,38 @@ void abort_import(void) unlink(import_stack[ptr].temp_name); } +static void switch_to_acf(void) +{ + int ptr = import_stack_ptr; + int ret, fd; + char *name; + FILE *f; + + assert(import_stack_ptr == 0); + + input_name = acf_name; + acf_name = NULL; + line_number = 1; + + name = xstrdup( "widl.XXXXXX" ); + if((fd = mkstemps( name, 0 )) == -1) + error("Could not generate a temp name from %s\n", name); + + temp_name = name; + if (!(f = fdopen(fd, "wt"))) + error("Could not open fd %s for writing\n", name); + + ret = wpp_parse(input_name, f); + fclose(f); + if (ret) exit(1); + + if((f = fopen(temp_name, "r")) == NULL) + error_loc("Unable to open %s\n", temp_name); + + import_stack[ptr].state = YY_CURRENT_BUFFER; + parser__switch_to_buffer(parser__create_buffer(f,YY_BUF_SIZE)); +} + static void warning_disable(int warning) { warning_t *warning_entry; diff --git a/sdk/tools/widl/parser.yy.h b/sdk/tools/widl/parser.yy.h index bddc1efd7b0..bfff33fc56b 100644 --- a/sdk/tools/widl/parser.yy.h +++ b/sdk/tools/widl/parser.yy.h @@ -317,7 +317,7 @@ extern int parser_lex (void); #undef YY_DECL #endif -#line 231 "parser.l" +#line 238 "parser.l" #line 324 "parser.yy.h" diff --git a/sdk/tools/widl/proxy.c b/sdk/tools/widl/proxy.c index 376326333e4..eefd6216881 100644 --- a/sdk/tools/widl/proxy.c +++ b/sdk/tools/widl/proxy.c @@ -116,7 +116,13 @@ static void clear_output_vars( const var_list_t *args ) if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_BASIC) continue; if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_ENUM) continue; } - print_proxy( "if (%s) MIDL_memset( %s, 0, sizeof( *%s ));\n", arg->name, arg->name, arg->name ); + print_proxy( "if (%s) MIDL_memset( %s, 0, ", arg->name, arg->name ); + if (is_array(arg->type) && type_array_has_conformance(arg->type)) + { + write_expr( proxy, type_array_get_conformance(arg->type), 1, 1, NULL, NULL, "" ); + fprintf( proxy, " * " ); + } + fprintf( proxy, "sizeof( *%s ));\n", arg->name ); } } @@ -158,7 +164,7 @@ static void free_variable( const var_t *arg, const char *local_var_prefix ) break; case TGT_STRUCT: - if (get_struct_fc(type) != RPC_FC_STRUCT) + if (get_struct_fc(type) != FC_STRUCT) print_proxy("/* FIXME: %s code for %s struct type 0x%x missing */\n", __FUNCTION__, arg->name, get_struct_fc(type) ); break; @@ -680,7 +686,8 @@ static void write_proxy(type_t *iface, unsigned int *proc_offset) /* proxy vtable */ print_proxy( "static %sCINTERFACE_PROXY_VTABLE(%d) _%sProxyVtbl =\n", - need_delegation_indirect(iface) ? "" : "const ", count, iface->name); + (get_stub_mode() != MODE_Os || need_delegation_indirect(iface)) ? "" : "const ", + count, iface->name); print_proxy( "{\n"); indent++; print_proxy( "{\n"); @@ -759,7 +766,9 @@ static void write_proxy(type_t *iface, unsigned int *proc_offset) print_proxy( "},\n"); print_proxy( "{\n"); indent++; - print_proxy( "CStdStubBuffer_%s\n", need_delegation_indirect(iface) ? "DELEGATING_METHODS" : "METHODS"); + print_proxy( "%s_%s\n", + iface->details.iface->async_iface == iface ? "CStdAsyncStubBuffer" : "CStdStubBuffer", + need_delegation_indirect(iface) ? "DELEGATING_METHODS" : "METHODS"); indent--; print_proxy( "}\n"); indent--; @@ -855,8 +864,13 @@ static void write_proxy_stmts(const statement_list_t *stmts, unsigned int *proc_ { 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); + type_t *iface = stmt->u.type; + if (need_proxy(iface)) + { + write_proxy(iface, proc_offset); + if (iface->details.iface->async_iface) + write_proxy(iface->details.iface->async_iface, proc_offset); + } } } } @@ -884,6 +898,12 @@ static void build_iface_list( const statement_list_t *stmts, type_t **ifaces[], { *ifaces = xrealloc( *ifaces, (*count + 1) * sizeof(**ifaces) ); (*ifaces)[(*count)++] = iface; + if (iface->details.iface->async_iface) + { + iface = iface->details.iface->async_iface; + *ifaces = xrealloc( *ifaces, (*count + 1) * sizeof(**ifaces) ); + (*ifaces)[(*count)++] = iface; + } } } } @@ -905,6 +925,7 @@ static void write_proxy_routines(const statement_list_t *stmts) unsigned int proc_offset = 0; char *file_id = proxy_token; int i, count, have_baseiid = 0; + unsigned int table_version; type_t **interfaces; const type_t * delegate_to; @@ -950,7 +971,7 @@ static void write_proxy_routines(const statement_list_t *stmts) write_stubdesc(expr_eval_routines); print_proxy( "#if !defined(__RPC_WIN%u__)\n", pointer_size == 8 ? 64 : 32); - print_proxy( "#error Currently only Wine and WIN32 are supported.\n"); + print_proxy( "#error Invalid build platform for this proxy.\n"); print_proxy( "#endif\n"); print_proxy( "\n"); write_procformatstring(proxy, stmts, need_proxy); @@ -1016,6 +1037,26 @@ static void write_proxy_routines(const statement_list_t *stmts) fprintf(proxy, "}\n"); fprintf(proxy, "\n"); + table_version = get_stub_mode() == MODE_Oif ? 2 : 1; + for (i = 0; i < count; i++) + { + if (interfaces[i]->details.iface->async_iface != interfaces[i]) continue; + if (table_version != 6) + { + fprintf(proxy, "static const IID *_AsyncInterfaceTable[] =\n"); + fprintf(proxy, "{\n"); + table_version = 6; + } + fprintf(proxy, " &IID_%s,\n", interfaces[i]->name); + fprintf(proxy, " (IID*)(LONG_PTR)-1,\n"); + } + if (table_version == 6) + { + fprintf(proxy, " 0\n"); + fprintf(proxy, "};\n"); + fprintf(proxy, "\n"); + } + fprintf(proxy, "const ExtendedProxyFileInfo %s_ProxyFileInfo DECLSPEC_HIDDEN =\n", file_id); fprintf(proxy, "{\n"); fprintf(proxy, " (const PCInterfaceProxyVtblList*)_%s_ProxyVtblList,\n", file_id); @@ -1025,8 +1066,8 @@ static void write_proxy_routines(const statement_list_t *stmts) else fprintf(proxy, " 0,\n"); fprintf(proxy, " _%s_IID_Lookup,\n", file_id); fprintf(proxy, " %d,\n", count); - fprintf(proxy, " %d,\n", get_stub_mode() == MODE_Oif ? 2 : 1); - fprintf(proxy, " 0,\n"); + fprintf(proxy, " %u,\n", table_version); + fprintf(proxy, " %s,\n", table_version == 6 ? "_AsyncInterfaceTable" : "0"); fprintf(proxy, " 0,\n"); fprintf(proxy, " 0,\n"); fprintf(proxy, " 0\n"); @@ -1041,26 +1082,6 @@ void write_proxies(const statement_list_t *stmts) init_proxy(stmts); if(!proxy) return; - if (do_win32 && do_win64) - { - fprintf(proxy, "\n#ifndef _WIN64\n\n"); - pointer_size = 4; - write_proxy_routines( stmts ); - fprintf(proxy, "\n#else /* _WIN64 */\n\n"); - pointer_size = 8; - write_proxy_routines( stmts ); - fprintf(proxy, "\n#endif /* _WIN64 */\n"); - } - else if (do_win32) - { - pointer_size = 4; - write_proxy_routines( stmts ); - } - else if (do_win64) - { - pointer_size = 8; - write_proxy_routines( stmts ); - } - + write_proxy_routines( stmts ); fclose(proxy); } diff --git a/sdk/tools/widl/register.c b/sdk/tools/widl/register.c index 9a4f21930e5..a6d1ef840f7 100644 --- a/sdk/tools/widl/register.c +++ b/sdk/tools/widl/register.c @@ -34,6 +34,9 @@ #include "parser.h" #include "header.h" #include "typegen.h" +#ifndef __REACTOS__ +#include "typelib.h" +#endif static int indent; @@ -273,6 +276,31 @@ void write_regscript( const statement_list_t *stmts ) } } +#ifndef __REACTOS__ +void write_typelib_regscript( const statement_list_t *stmts ) +{ + const statement_t *stmt; + unsigned int count = 0; + + if (!do_typelib) return; + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) + { + if (stmt->type != STMT_LIBRARY) continue; + if (count && !strendswith( typelib_name, ".res" )) + error( "Cannot store multiple typelibs into %s\n", typelib_name ); + else + { + if (do_old_typelib) + create_sltg_typelib( stmt->u.lib ); + else + create_msft_typelib( stmt->u.lib ); + } + count++; + } + if (count && strendswith( typelib_name, ".res" )) flush_output_resources( typelib_name ); +} +#endif + void output_typelib_regscript( const typelib_t *typelib ) { const UUID *typelib_uuid = get_attrp( typelib->attrs, ATTR_UUID ); @@ -281,6 +309,9 @@ void output_typelib_regscript( const typelib_t *typelib ) unsigned int version = get_attrv( typelib->attrs, ATTR_VERSION ); unsigned int flags = 0; char id_part[12] = ""; +#ifndef __REACTOS__ + char *resname = typelib_name; +#endif expr_t *expr; if (is_attr( typelib->attrs, ATTR_RESTRICTED )) flags |= 1; /* LIBFLAG_FRESTRICTED */ @@ -298,10 +329,19 @@ void output_typelib_regscript( const typelib_t *typelib ) MAJORVERSION(version), MINORVERSION(version), descr ? descr : typelib->name ); put_str( indent++, "{\n" ); expr = get_attrp( typelib->attrs, ATTR_ID ); +#ifdef __REACTOS__ if (expr) sprintf(id_part, "\\%d", expr->cval); +#else + if (expr) + { + sprintf(id_part, "\\%d", expr->cval); + resname = xmalloc( strlen(typelib_name) + 20 ); + sprintf(resname, "%s\\%d", typelib_name, expr->cval); + } +#endif put_str( indent, "'%x' { %s = s '%%MODULE%%%s' }\n", - lcid_expr ? lcid_expr->cval : 0, typelib_kind == SYS_WIN64 ? "win64" : "win32", id_part ); + lcid_expr ? lcid_expr->cval : 0, pointer_size == 8 ? "win64" : "win32", id_part ); put_str( indent, "FLAGS = s '%u'\n", flags ); put_str( --indent, "}\n" ); put_str( --indent, "}\n" ); @@ -319,6 +359,9 @@ void output_typelib_regscript( const typelib_t *typelib ) write_progids( typelib->stmts ); put_str( --indent, "}\n" ); - +#ifdef __REACTOS__ add_output_to_resources( "WINE_REGISTRY", typelib_name ); +#else + add_output_to_resources( "WINE_REGISTRY", resname ); +#endif } diff --git a/sdk/tools/widl/server.c b/sdk/tools/widl/server.c index 29b5beca250..d165bbb0490 100644 --- a/sdk/tools/widl/server.c +++ b/sdk/tools/widl/server.c @@ -104,7 +104,7 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned write_parameters_init(server, indent, func, "__frame->"); - if (explicit_fc == RPC_FC_BIND_PRIMITIVE) + if (explicit_fc == FC_BIND_PRIMITIVE) { print_server("__frame->%s = _pRpcMessage->Handle;\n", handle_var->name); fprintf(server, "\n"); @@ -544,26 +544,6 @@ void write_server(const statement_list_t *stmts) if (!server) return; - if (do_win32 && do_win64) - { - fprintf(server, "#ifndef _WIN64\n\n"); - pointer_size = 4; - write_server_routines( stmts ); - fprintf(server, "\n#else /* _WIN64 */\n\n"); - pointer_size = 8; - write_server_routines( stmts ); - fprintf(server, "\n#endif /* _WIN64 */\n"); - } - else if (do_win32) - { - pointer_size = 4; - write_server_routines( stmts ); - } - else if (do_win64) - { - pointer_size = 8; - write_server_routines( stmts ); - } - + write_server_routines( stmts ); fclose(server); } diff --git a/sdk/tools/widl/typegen.c b/sdk/tools/widl/typegen.c index c2e3fd6f503..0bca062ab4b 100644 --- a/sdk/tools/widl/typegen.c +++ b/sdk/tools/widl/typegen.c @@ -84,7 +84,6 @@ static const unsigned short IsSimpleRef = 0x0100; static unsigned int field_memsize(const type_t *type, unsigned int *offset); static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align); -static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align); static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type, const char *name, unsigned int *typestring_offset); static unsigned int write_struct_tfs(FILE *file, type_t *type, const char *name, unsigned int *tfsoff); @@ -103,86 +102,86 @@ static const char *string_of_type(unsigned char type) { switch (type) { - case RPC_FC_BYTE: return "FC_BYTE"; - case RPC_FC_CHAR: return "FC_CHAR"; - case RPC_FC_SMALL: return "FC_SMALL"; - case RPC_FC_USMALL: return "FC_USMALL"; - case RPC_FC_WCHAR: return "FC_WCHAR"; - case RPC_FC_SHORT: return "FC_SHORT"; - case RPC_FC_USHORT: return "FC_USHORT"; - case RPC_FC_LONG: return "FC_LONG"; - case RPC_FC_ULONG: return "FC_ULONG"; - case RPC_FC_FLOAT: return "FC_FLOAT"; - case RPC_FC_HYPER: return "FC_HYPER"; - case RPC_FC_DOUBLE: return "FC_DOUBLE"; - case RPC_FC_ENUM16: return "FC_ENUM16"; - case RPC_FC_ENUM32: return "FC_ENUM32"; - case RPC_FC_IGNORE: return "FC_IGNORE"; - case RPC_FC_ERROR_STATUS_T: return "FC_ERROR_STATUS_T"; - case RPC_FC_RP: return "FC_RP"; - case RPC_FC_UP: return "FC_UP"; - case RPC_FC_OP: return "FC_OP"; - case RPC_FC_FP: return "FC_FP"; - case RPC_FC_ENCAPSULATED_UNION: return "FC_ENCAPSULATED_UNION"; - case RPC_FC_NON_ENCAPSULATED_UNION: return "FC_NON_ENCAPSULATED_UNION"; - case RPC_FC_STRUCT: return "FC_STRUCT"; - case RPC_FC_PSTRUCT: return "FC_PSTRUCT"; - case RPC_FC_CSTRUCT: return "FC_CSTRUCT"; - case RPC_FC_CPSTRUCT: return "FC_CPSTRUCT"; - case RPC_FC_CVSTRUCT: return "FC_CVSTRUCT"; - case RPC_FC_BOGUS_STRUCT: return "FC_BOGUS_STRUCT"; - case RPC_FC_SMFARRAY: return "FC_SMFARRAY"; - case RPC_FC_LGFARRAY: return "FC_LGFARRAY"; - case RPC_FC_SMVARRAY: return "FC_SMVARRAY"; - case RPC_FC_LGVARRAY: return "FC_LGVARRAY"; - case RPC_FC_CARRAY: return "FC_CARRAY"; - case RPC_FC_CVARRAY: return "FC_CVARRAY"; - case RPC_FC_BOGUS_ARRAY: return "FC_BOGUS_ARRAY"; - case RPC_FC_ALIGNM2: return "FC_ALIGNM2"; - case RPC_FC_ALIGNM4: return "FC_ALIGNM4"; - case RPC_FC_ALIGNM8: return "FC_ALIGNM8"; - case RPC_FC_POINTER: return "FC_POINTER"; - case RPC_FC_C_CSTRING: return "FC_C_CSTRING"; - case RPC_FC_C_WSTRING: return "FC_C_WSTRING"; - case RPC_FC_CSTRING: return "FC_CSTRING"; - case RPC_FC_WSTRING: return "FC_WSTRING"; - case RPC_FC_BYTE_COUNT_POINTER: return "FC_BYTE_COUNT_POINTER"; - case RPC_FC_TRANSMIT_AS: return "FC_TRANSMIT_AS"; - case RPC_FC_REPRESENT_AS: return "FC_REPRESENT_AS"; - case RPC_FC_IP: return "FC_IP"; - case RPC_FC_BIND_CONTEXT: return "FC_BIND_CONTEXT"; - case RPC_FC_BIND_GENERIC: return "FC_BIND_GENERIC"; - case RPC_FC_BIND_PRIMITIVE: return "FC_BIND_PRIMITIVE"; - case RPC_FC_AUTO_HANDLE: return "FC_AUTO_HANDLE"; - case RPC_FC_CALLBACK_HANDLE: return "FC_CALLBACK_HANDLE"; - case RPC_FC_STRUCTPAD1: return "FC_STRUCTPAD1"; - case RPC_FC_STRUCTPAD2: return "FC_STRUCTPAD2"; - case RPC_FC_STRUCTPAD3: return "FC_STRUCTPAD3"; - case RPC_FC_STRUCTPAD4: return "FC_STRUCTPAD4"; - case RPC_FC_STRUCTPAD5: return "FC_STRUCTPAD5"; - case RPC_FC_STRUCTPAD6: return "FC_STRUCTPAD6"; - case RPC_FC_STRUCTPAD7: return "FC_STRUCTPAD7"; - case RPC_FC_STRING_SIZED: return "FC_STRING_SIZED"; - case RPC_FC_NO_REPEAT: return "FC_NO_REPEAT"; - case RPC_FC_FIXED_REPEAT: return "FC_FIXED_REPEAT"; - case RPC_FC_VARIABLE_REPEAT: return "FC_VARIABLE_REPEAT"; - case RPC_FC_FIXED_OFFSET: return "FC_FIXED_OFFSET"; - case RPC_FC_VARIABLE_OFFSET: return "FC_VARIABLE_OFFSET"; - case RPC_FC_PP: return "FC_PP"; - case RPC_FC_EMBEDDED_COMPLEX: return "FC_EMBEDDED_COMPLEX"; - case RPC_FC_DEREFERENCE: return "FC_DEREFERENCE"; - case RPC_FC_DIV_2: return "FC_DIV_2"; - case RPC_FC_MULT_2: return "FC_MULT_2"; - case RPC_FC_ADD_1: return "FC_ADD_1"; - case RPC_FC_SUB_1: return "FC_SUB_1"; - case RPC_FC_CALLBACK: return "FC_CALLBACK"; - case RPC_FC_CONSTANT_IID: return "FC_CONSTANT_IID"; - case RPC_FC_END: return "FC_END"; - case RPC_FC_PAD: return "FC_PAD"; - case RPC_FC_USER_MARSHAL: return "FC_USER_MARSHAL"; - case RPC_FC_RANGE: return "FC_RANGE"; - case RPC_FC_INT3264: return "FC_INT3264"; - case RPC_FC_UINT3264: return "FC_UINT3264"; + case FC_BYTE: return "FC_BYTE"; + case FC_CHAR: return "FC_CHAR"; + case FC_SMALL: return "FC_SMALL"; + case FC_USMALL: return "FC_USMALL"; + case FC_WCHAR: return "FC_WCHAR"; + case FC_SHORT: return "FC_SHORT"; + case FC_USHORT: return "FC_USHORT"; + case FC_LONG: return "FC_LONG"; + case FC_ULONG: return "FC_ULONG"; + case FC_FLOAT: return "FC_FLOAT"; + case FC_HYPER: return "FC_HYPER"; + case FC_DOUBLE: return "FC_DOUBLE"; + case FC_ENUM16: return "FC_ENUM16"; + case FC_ENUM32: return "FC_ENUM32"; + case FC_IGNORE: return "FC_IGNORE"; + case FC_ERROR_STATUS_T: return "FC_ERROR_STATUS_T"; + case FC_RP: return "FC_RP"; + case FC_UP: return "FC_UP"; + case FC_OP: return "FC_OP"; + case FC_FP: return "FC_FP"; + case FC_ENCAPSULATED_UNION: return "FC_ENCAPSULATED_UNION"; + case FC_NON_ENCAPSULATED_UNION: return "FC_NON_ENCAPSULATED_UNION"; + case FC_STRUCT: return "FC_STRUCT"; + case FC_PSTRUCT: return "FC_PSTRUCT"; + case FC_CSTRUCT: return "FC_CSTRUCT"; + case FC_CPSTRUCT: return "FC_CPSTRUCT"; + case FC_CVSTRUCT: return "FC_CVSTRUCT"; + case FC_BOGUS_STRUCT: return "FC_BOGUS_STRUCT"; + case FC_SMFARRAY: return "FC_SMFARRAY"; + case FC_LGFARRAY: return "FC_LGFARRAY"; + case FC_SMVARRAY: return "FC_SMVARRAY"; + case FC_LGVARRAY: return "FC_LGVARRAY"; + case FC_CARRAY: return "FC_CARRAY"; + case FC_CVARRAY: return "FC_CVARRAY"; + case FC_BOGUS_ARRAY: return "FC_BOGUS_ARRAY"; + case FC_ALIGNM2: return "FC_ALIGNM2"; + case FC_ALIGNM4: return "FC_ALIGNM4"; + case FC_ALIGNM8: return "FC_ALIGNM8"; + case FC_POINTER: return "FC_POINTER"; + case FC_C_CSTRING: return "FC_C_CSTRING"; + case FC_C_WSTRING: return "FC_C_WSTRING"; + case FC_CSTRING: return "FC_CSTRING"; + case FC_WSTRING: return "FC_WSTRING"; + case FC_BYTE_COUNT_POINTER: return "FC_BYTE_COUNT_POINTER"; + case FC_TRANSMIT_AS: return "FC_TRANSMIT_AS"; + case FC_REPRESENT_AS: return "FC_REPRESENT_AS"; + case FC_IP: return "FC_IP"; + case FC_BIND_CONTEXT: return "FC_BIND_CONTEXT"; + case FC_BIND_GENERIC: return "FC_BIND_GENERIC"; + case FC_BIND_PRIMITIVE: return "FC_BIND_PRIMITIVE"; + case FC_AUTO_HANDLE: return "FC_AUTO_HANDLE"; + case FC_CALLBACK_HANDLE: return "FC_CALLBACK_HANDLE"; + case FC_STRUCTPAD1: return "FC_STRUCTPAD1"; + case FC_STRUCTPAD2: return "FC_STRUCTPAD2"; + case FC_STRUCTPAD3: return "FC_STRUCTPAD3"; + case FC_STRUCTPAD4: return "FC_STRUCTPAD4"; + case FC_STRUCTPAD5: return "FC_STRUCTPAD5"; + case FC_STRUCTPAD6: return "FC_STRUCTPAD6"; + case FC_STRUCTPAD7: return "FC_STRUCTPAD7"; + case FC_STRING_SIZED: return "FC_STRING_SIZED"; + case FC_NO_REPEAT: return "FC_NO_REPEAT"; + case FC_FIXED_REPEAT: return "FC_FIXED_REPEAT"; + case FC_VARIABLE_REPEAT: return "FC_VARIABLE_REPEAT"; + case FC_FIXED_OFFSET: return "FC_FIXED_OFFSET"; + case FC_VARIABLE_OFFSET: return "FC_VARIABLE_OFFSET"; + case FC_PP: return "FC_PP"; + case FC_EMBEDDED_COMPLEX: return "FC_EMBEDDED_COMPLEX"; + case FC_DEREFERENCE: return "FC_DEREFERENCE"; + case FC_DIV_2: return "FC_DIV_2"; + case FC_MULT_2: return "FC_MULT_2"; + case FC_ADD_1: return "FC_ADD_1"; + case FC_SUB_1: return "FC_SUB_1"; + case FC_CALLBACK: return "FC_CALLBACK"; + case FC_CONSTANT_IID: return "FC_CONSTANT_IID"; + case FC_END: return "FC_END"; + case FC_PAD: return "FC_PAD"; + case FC_USER_MARSHAL: return "FC_USER_MARSHAL"; + case FC_RANGE: return "FC_RANGE"; + case FC_INT3264: return "FC_INT3264"; + case FC_UINT3264: return "FC_UINT3264"; default: error("string_of_type: unknown type 0x%02x\n", type); return NULL; @@ -207,20 +206,21 @@ unsigned char get_basic_fc(const type_t *type) int sign = type_basic_get_sign(type); switch (type_basic_get_type(type)) { - case TYPE_BASIC_INT8: return (sign <= 0 ? RPC_FC_SMALL : RPC_FC_USMALL); - case TYPE_BASIC_INT16: return (sign <= 0 ? RPC_FC_SHORT : RPC_FC_USHORT); - case TYPE_BASIC_INT32: return (sign <= 0 ? RPC_FC_LONG : RPC_FC_ULONG); - case TYPE_BASIC_INT64: return RPC_FC_HYPER; - case TYPE_BASIC_INT: return (sign <= 0 ? RPC_FC_LONG : RPC_FC_ULONG); - case TYPE_BASIC_INT3264: return (sign <= 0 ? RPC_FC_INT3264 : RPC_FC_UINT3264); - case TYPE_BASIC_BYTE: return RPC_FC_BYTE; - case TYPE_BASIC_CHAR: return RPC_FC_CHAR; - case TYPE_BASIC_WCHAR: return RPC_FC_WCHAR; - case TYPE_BASIC_HYPER: return RPC_FC_HYPER; - case TYPE_BASIC_FLOAT: return RPC_FC_FLOAT; - case TYPE_BASIC_DOUBLE: return RPC_FC_DOUBLE; - case TYPE_BASIC_ERROR_STATUS_T: return RPC_FC_ERROR_STATUS_T; - case TYPE_BASIC_HANDLE: return RPC_FC_BIND_PRIMITIVE; + case TYPE_BASIC_INT8: return (sign <= 0 ? FC_SMALL : FC_USMALL); + case TYPE_BASIC_INT16: return (sign <= 0 ? FC_SHORT : FC_USHORT); + case TYPE_BASIC_INT32: + case TYPE_BASIC_LONG: return (sign <= 0 ? FC_LONG : FC_ULONG); + case TYPE_BASIC_INT64: return FC_HYPER; + case TYPE_BASIC_INT: return (sign <= 0 ? FC_LONG : FC_ULONG); + case TYPE_BASIC_INT3264: return (sign <= 0 ? FC_INT3264 : FC_UINT3264); + case TYPE_BASIC_BYTE: return FC_BYTE; + case TYPE_BASIC_CHAR: return FC_CHAR; + case TYPE_BASIC_WCHAR: return FC_WCHAR; + case TYPE_BASIC_HYPER: return FC_HYPER; + case TYPE_BASIC_FLOAT: return FC_FLOAT; + case TYPE_BASIC_DOUBLE: return FC_DOUBLE; + case TYPE_BASIC_ERROR_STATUS_T: return FC_ERROR_STATUS_T; + case TYPE_BASIC_HANDLE: return FC_BIND_PRIMITIVE; } return 0; } @@ -229,20 +229,21 @@ static unsigned char get_basic_fc_signed(const type_t *type) { switch (type_basic_get_type(type)) { - case TYPE_BASIC_INT8: return RPC_FC_SMALL; - case TYPE_BASIC_INT16: return RPC_FC_SHORT; - case TYPE_BASIC_INT32: return RPC_FC_LONG; - case TYPE_BASIC_INT64: return RPC_FC_HYPER; - case TYPE_BASIC_INT: return RPC_FC_LONG; - case TYPE_BASIC_INT3264: return RPC_FC_INT3264; - case TYPE_BASIC_BYTE: return RPC_FC_BYTE; - case TYPE_BASIC_CHAR: return RPC_FC_CHAR; - case TYPE_BASIC_WCHAR: return RPC_FC_WCHAR; - case TYPE_BASIC_HYPER: return RPC_FC_HYPER; - case TYPE_BASIC_FLOAT: return RPC_FC_FLOAT; - case TYPE_BASIC_DOUBLE: return RPC_FC_DOUBLE; - case TYPE_BASIC_ERROR_STATUS_T: return RPC_FC_ERROR_STATUS_T; - case TYPE_BASIC_HANDLE: return RPC_FC_BIND_PRIMITIVE; + case TYPE_BASIC_INT8: return FC_SMALL; + case TYPE_BASIC_INT16: return FC_SHORT; + case TYPE_BASIC_INT32: return FC_LONG; + case TYPE_BASIC_INT64: return FC_HYPER; + case TYPE_BASIC_INT: return FC_LONG; + case TYPE_BASIC_INT3264: return FC_INT3264; + case TYPE_BASIC_LONG: return FC_LONG; + case TYPE_BASIC_BYTE: return FC_BYTE; + case TYPE_BASIC_CHAR: return FC_CHAR; + case TYPE_BASIC_WCHAR: return FC_WCHAR; + case TYPE_BASIC_HYPER: return FC_HYPER; + case TYPE_BASIC_FLOAT: return FC_FLOAT; + case TYPE_BASIC_DOUBLE: return FC_DOUBLE; + case TYPE_BASIC_ERROR_STATUS_T: return FC_ERROR_STATUS_T; + case TYPE_BASIC_HANDLE: return FC_BIND_PRIMITIVE; } return 0; } @@ -273,7 +274,7 @@ unsigned char get_pointer_fc(const type_t *type, const attr_list_t *attrs, int t } if (toplevel_param) - return RPC_FC_RP; + return FC_RP; else if (is_ptr(type)) return type_pointer_get_default_fc(type); else @@ -285,9 +286,9 @@ static unsigned char get_pointer_fc_context( const type_t *type, const attr_list { int pointer_fc = get_pointer_fc(type, attrs, context == TYPE_CONTEXT_TOPLEVELPARAM); - if (pointer_fc == RPC_FC_UP && is_attr( attrs, ATTR_OUT ) && + if (pointer_fc == FC_UP && is_attr( attrs, ATTR_OUT ) && context == TYPE_CONTEXT_PARAM && is_object( current_iface )) - pointer_fc = RPC_FC_OP; + pointer_fc = FC_OP; return pointer_fc; } @@ -296,9 +297,9 @@ static unsigned char get_enum_fc(const type_t *type) { assert(type_get_type(type) == TYPE_ENUM); if (is_aliaschain_attr(type, ATTR_V1ENUM)) - return RPC_FC_ENUM32; + return FC_ENUM32; else - return RPC_FC_ENUM16; + return FC_ENUM16; } static type_t *get_user_type(const type_t *t, const char **pname) @@ -383,7 +384,7 @@ static int cant_be_null(const var_t *v) if (!type_array_is_decl_as_ptr( v->type )) return 0; /* fall through */ case TGT_POINTER: - return (get_pointer_fc(v->type, v->attrs, TRUE) == RPC_FC_RP); + return (get_pointer_fc(v->type, v->attrs, TRUE) == FC_RP); case TGT_CTXT_HANDLE_POINTER: return TRUE; default: @@ -485,7 +486,7 @@ unsigned char get_struct_fc(const type_t *type) fields = type_struct_get_fields(type); if (get_padding(fields)) - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry ) { @@ -505,7 +506,7 @@ unsigned char get_struct_fc(const type_t *type) } if (is_array(type_array_get_element(field->type))) - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; if (type_array_has_conformance(field->type)) { @@ -525,37 +526,37 @@ unsigned char get_struct_fc(const type_t *type) { case TGT_USER_TYPE: case TGT_IFACE_POINTER: - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; case TGT_BASIC: if (type_basic_get_type(t) == TYPE_BASIC_INT3264 && pointer_size != 4) - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; break; case TGT_ENUM: - if (get_enum_fc(t) == RPC_FC_ENUM16) - return RPC_FC_BOGUS_STRUCT; + if (get_enum_fc(t) == FC_ENUM16) + return FC_BOGUS_STRUCT; break; case TGT_POINTER: case TGT_ARRAY: - if (get_pointer_fc(t, field->attrs, FALSE) == RPC_FC_RP || pointer_size != 4) - return RPC_FC_BOGUS_STRUCT; + if (get_pointer_fc(t, field->attrs, FALSE) == FC_RP || pointer_size != 4) + return FC_BOGUS_STRUCT; has_pointer = 1; break; case TGT_UNION: - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; case TGT_STRUCT: { unsigned char fc = get_struct_fc(t); switch (fc) { - case RPC_FC_STRUCT: + case FC_STRUCT: break; - case RPC_FC_CVSTRUCT: + case FC_CVSTRUCT: has_conformance = 1; has_variance = 1; has_pointer = 1; break; - case RPC_FC_CPSTRUCT: + case FC_CPSTRUCT: has_conformance = 1; if (list_next( fields, &field->entry )) error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n", @@ -563,14 +564,14 @@ unsigned char get_struct_fc(const type_t *type) has_pointer = 1; break; - case RPC_FC_CSTRUCT: + case FC_CSTRUCT: has_conformance = 1; if (list_next( fields, &field->entry )) error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n", field->name); break; - case RPC_FC_PSTRUCT: + case FC_PSTRUCT: has_pointer = 1; break; @@ -579,13 +580,13 @@ unsigned char get_struct_fc(const type_t *type) /* fallthru - treat it as complex */ /* as soon as we see one of these these members, it's bogus... */ - case RPC_FC_BOGUS_STRUCT: - return RPC_FC_BOGUS_STRUCT; + case FC_BOGUS_STRUCT: + return FC_BOGUS_STRUCT; } break; } case TGT_RANGE: - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; case TGT_STRING: /* shouldn't get here because of TDT_IGNORE_STRINGS above. fall through */ case TGT_INVALID: @@ -600,17 +601,17 @@ unsigned char get_struct_fc(const type_t *type) if( has_variance ) { if ( has_conformance ) - return RPC_FC_CVSTRUCT; + return FC_CVSTRUCT; else - return RPC_FC_BOGUS_STRUCT; + return FC_BOGUS_STRUCT; } if( has_conformance && has_pointer ) - return RPC_FC_CPSTRUCT; + return FC_CPSTRUCT; if( has_conformance ) - return RPC_FC_CSTRUCT; + return FC_CSTRUCT; if( has_pointer ) - return RPC_FC_PSTRUCT; - return RPC_FC_STRUCT; + return FC_PSTRUCT; + return FC_STRUCT; } static unsigned char get_array_fc(const type_t *type) @@ -626,60 +627,60 @@ static unsigned char get_array_fc(const type_t *type) { unsigned int size = type_memsize(elem_type); if (size * type_array_get_dim(type) > 0xffffuL) - fc = RPC_FC_LGFARRAY; + fc = FC_LGFARRAY; else - fc = RPC_FC_SMFARRAY; + fc = FC_SMFARRAY; } else - fc = RPC_FC_CARRAY; + fc = FC_CARRAY; if (type_array_has_variance(type)) { - if (fc == RPC_FC_SMFARRAY) - fc = RPC_FC_SMVARRAY; - else if (fc == RPC_FC_LGFARRAY) - fc = RPC_FC_LGVARRAY; - else if (fc == RPC_FC_CARRAY) - fc = RPC_FC_CVARRAY; + if (fc == FC_SMFARRAY) + fc = FC_SMVARRAY; + else if (fc == FC_LGFARRAY) + fc = FC_LGVARRAY; + else if (fc == FC_CARRAY) + fc = FC_CVARRAY; } switch (typegen_detect_type(elem_type, NULL, TDT_IGNORE_STRINGS)) { case TGT_USER_TYPE: - fc = RPC_FC_BOGUS_ARRAY; + fc = FC_BOGUS_ARRAY; break; case TGT_BASIC: if (type_basic_get_type(elem_type) == TYPE_BASIC_INT3264 && pointer_size != 4) - fc = RPC_FC_BOGUS_ARRAY; + fc = FC_BOGUS_ARRAY; break; case TGT_STRUCT: switch (get_struct_fc(elem_type)) { - case RPC_FC_BOGUS_STRUCT: - fc = RPC_FC_BOGUS_ARRAY; + case FC_BOGUS_STRUCT: + fc = FC_BOGUS_ARRAY; break; } break; case TGT_ENUM: /* is 16-bit enum - if so, wire size differs from mem size and so * the array cannot be block copied, which means the array is complex */ - if (get_enum_fc(elem_type) == RPC_FC_ENUM16) - fc = RPC_FC_BOGUS_ARRAY; + if (get_enum_fc(elem_type) == FC_ENUM16) + fc = FC_BOGUS_ARRAY; break; case TGT_UNION: case TGT_IFACE_POINTER: - fc = RPC_FC_BOGUS_ARRAY; + fc = FC_BOGUS_ARRAY; break; case TGT_POINTER: /* ref pointers cannot just be block copied. unique pointers to * interfaces need special treatment. either case means the array is * complex */ - if (get_pointer_fc(elem_type, NULL, FALSE) == RPC_FC_RP || pointer_size != 4) - fc = RPC_FC_BOGUS_ARRAY; + if (get_pointer_fc(elem_type, NULL, FALSE) == FC_RP || pointer_size != 4) + fc = FC_BOGUS_ARRAY; break; case TGT_RANGE: - fc = RPC_FC_BOGUS_ARRAY; + fc = FC_BOGUS_ARRAY; break; case TGT_CTXT_HANDLE: case TGT_CTXT_HANDLE_POINTER: @@ -696,7 +697,7 @@ static unsigned char get_array_fc(const type_t *type) static int is_non_complex_struct(const type_t *type) { return (type_get_type(type) == TYPE_STRUCT && - get_struct_fc(type) != RPC_FC_BOGUS_STRUCT); + get_struct_fc(type) != FC_BOGUS_STRUCT); } static int type_has_pointers(const type_t *type) @@ -754,12 +755,12 @@ static int type_has_full_pointer(const type_t *type, const attr_list_t *attrs, case TGT_USER_TYPE: return FALSE; case TGT_POINTER: - if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_FP) + if (get_pointer_fc(type, attrs, toplevel_param) == FC_FP) return TRUE; else return FALSE; case TGT_ARRAY: - if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_FP) + if (get_pointer_fc(type, attrs, toplevel_param) == FC_FP) return TRUE; else return type_has_full_pointer(type_array_get_element(type), NULL, FALSE); @@ -862,7 +863,7 @@ static const char *get_context_handle_type_name(const type_t *type) do { \ if (file) \ fprintf(file, "/* %2u */\n", typestring_offset); \ - print_file((file), 2, "0x%02x,\t/* " #fctype " */\n", RPC_##fctype); \ + print_file((file), 2, "0x%02x,\t/* " #fctype " */\n", fctype); \ } \ while (0) @@ -982,10 +983,10 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned case TGT_BASIC: *flags |= IsBasetype; fc = get_basic_fc_signed( var->type ); - if (fc == RPC_FC_BIND_PRIMITIVE) + if (fc == FC_BIND_PRIMITIVE) { buffer_size = 4; /* actually 0 but avoids setting MustSize */ - fc = RPC_FC_LONG; + fc = FC_LONG; } break; case TGT_ENUM: @@ -1006,7 +1007,7 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned case TGT_ARRAY: *flags |= MustFree; 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) + get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) { *typestring_offset = var->type->typestring_offset; *flags |= IsSimpleRef; @@ -1014,7 +1015,7 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned break; case TGT_STRING: *flags |= MustFree; - if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) + if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) { /* skip over pointer description straight to string description */ if (is_conformant_array( var->type )) *typestring_offset += 4; @@ -1030,7 +1031,7 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned buffer_size = 20; break; case TGT_POINTER: - if (get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) + if (get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) { const type_t *ref = type_pointer_get_ref( var->type ); @@ -1045,7 +1046,7 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned if (!is_in && is_out) server_size = pointer_size; break; case TGT_ENUM: - if ((fc = get_enum_fc( ref )) == RPC_FC_ENUM32) + if ((fc = get_enum_fc( ref )) == FC_ENUM32) { *flags |= IsSimpleRef | IsBasetype; if (!is_in && is_out) server_size = pointer_size; @@ -1058,13 +1059,13 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned case TGT_UNION: case TGT_USER_TYPE: case TGT_RANGE: + case TGT_ARRAY: *flags |= IsSimpleRef | MustFree; *typestring_offset = ref->typestring_offset; if (!is_in && is_out) server_size = type_memsize( ref ); break; case TGT_STRING: case TGT_POINTER: - case TGT_ARRAY: case TGT_CTXT_HANDLE: case TGT_CTXT_HANDLE_POINTER: *flags |= MustFree; @@ -1079,9 +1080,9 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned *typestring_offset = ref->typestring_offset; switch (get_struct_fc(ref)) { - case RPC_FC_STRUCT: - case RPC_FC_PSTRUCT: - case RPC_FC_BOGUS_STRUCT: + case FC_STRUCT: + case FC_PSTRUCT: + case FC_BOGUS_STRUCT: if (!is_in && is_out) server_size = type_memsize( ref ); break; default: @@ -1202,8 +1203,8 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons { fc = get_basic_fc_signed(var->type); - if (fc == RPC_FC_BIND_PRIMITIVE) - fc = RPC_FC_IGNORE; + if (fc == FC_BIND_PRIMITIVE) + fc = FC_IGNORE; } print_file(file, indent, "0x%02x, /* %s */\n", @@ -1295,7 +1296,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, unsigned char explicit_fc, implicit_fc; unsigned char handle_flags; const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); - unsigned char oi_flags = RPC_FC_PROC_OIF_RPCFLAGS | RPC_FC_PROC_OIF_NEWINIT; + unsigned char oi_flags = Oi_HAS_RPCFLAGS | Oi_USE_NEW_INIT_ROUTINES; unsigned int rpc_flags = get_rpc_flags( func->attrs ); unsigned int nb_args = 0; unsigned int stack_size = 0; @@ -1303,11 +1304,11 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, unsigned short handle_stack_offset = 0; unsigned short handle_param_num = 0; - if (is_full_pointer_function( func )) oi_flags |= RPC_FC_PROC_OIF_FULLPTR; + if (is_full_pointer_function( func )) oi_flags |= Oi_FULL_PTR_USED; if (is_object( iface )) { - oi_flags |= RPC_FC_PROC_OIF_OBJECT; - if (get_stub_mode() == MODE_Oif) oi_flags |= RPC_FC_PROC_OIF_OBJ_V2; + oi_flags |= Oi_OBJECT_PROC; + if (get_stub_mode() == MODE_Oif) oi_flags |= Oi_OBJ_USE_V2_INTERPRETER; stack_size += pointer_size; } @@ -1341,7 +1342,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, { switch (explicit_fc) { - case RPC_FC_BIND_PRIMITIVE: + case FC_BIND_PRIMITIVE: handle_flags = 0; print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); print_file( file, indent, "0x%02x,\n", handle_flags ); @@ -1349,17 +1350,17 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, handle_stack_offset, handle_stack_offset ); *offset += 4; break; - case RPC_FC_BIND_GENERIC: + case FC_BIND_GENERIC: handle_flags = type_memsize( handle_var->type ); print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); print_file( file, indent, "0x%02x,\n", handle_flags ); print_file( file, indent, "NdrFcShort(0x%hx),\t/* stack offset = %hu */\n", handle_stack_offset, handle_stack_offset ); print_file( file, indent, "0x%02x,\n", get_generic_handle_offset( handle_var->type ) ); - print_file( file, indent, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); + print_file( file, indent, "0x%x,\t/* FC_PAD */\n", FC_PAD); *offset += 6; break; - case RPC_FC_BIND_CONTEXT: + case FC_BIND_CONTEXT: handle_flags = get_contexthandle_flags( iface, handle_var->attrs, handle_var->type ); print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); print_file( file, indent, "0x%02x,\n", handle_flags ); @@ -1380,6 +1381,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, if (is_attr( func->attrs, ATTR_NOTIFY )) ext_flags |= 0x08; /* HasNotify */ if (is_attr( func->attrs, ATTR_NOTIFYFLAG )) ext_flags |= 0x10; /* HasNotify2 */ + if (iface == iface->details.iface->async_iface) oi2_flags |= 0x20; size = get_function_buffer_size( func, PASS_IN ); print_file( file, indent, "NdrFcShort(0x%x),\t/* client buffer = %u */\n", size, size ); @@ -1464,27 +1466,36 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i } } -static void write_procformatstring_stmts(FILE *file, int indent, const statement_list_t *stmts, - type_pred_t pred, unsigned int *offset) +static void for_each_iface(const statement_list_t *stmts, + void (*proc)(type_t *iface, FILE *file, int indent, unsigned int *offset), + type_pred_t pred, FILE *file, int indent, unsigned int *offset) { const statement_t *stmt; + type_t *iface; + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) { - if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) - { - const statement_t *stmt_func; - const type_t *iface = stmt->u.type; - const type_t *parent = type_iface_get_inherit( iface ); - int count = parent ? count_methods( parent ) : 0; + if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) + continue; + iface = stmt->u.type; + if (!pred(iface)) continue; + proc(iface, file, indent, offset); + if (iface->details.iface->async_iface) + proc(iface->details.iface->async_iface, file, indent, offset); + } +} - if (!pred(iface)) continue; - STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(iface)) - { - var_t *func = stmt_func->u.var; - if (is_local(func->attrs)) continue; - write_procformatstring_func( file, indent, iface, func, offset, count++ ); - } - } +static void write_iface_procformatstring(type_t *iface, FILE *file, int indent, unsigned int *offset) +{ + const statement_t *stmt; + const type_t *parent = type_iface_get_inherit( iface ); + int count = parent ? count_methods( parent ) : 0; + + STATEMENTS_FOR_EACH_FUNC(stmt, type_iface_get_stmts(iface)) + { + var_t *func = stmt->u.var; + if (is_local(func->attrs)) continue; + write_procformatstring_func( file, indent, iface, func, offset, count++ ); } } @@ -1500,7 +1511,7 @@ void write_procformatstring(FILE *file, const statement_list_t *stmts, type_pred print_file(file, indent, "{\n"); indent++; - write_procformatstring_stmts(file, indent, stmts, pred, &offset); + for_each_iface(stmts, write_iface_procformatstring, pred, file, indent, &offset); print_file(file, indent, "0x0\n"); indent--; @@ -1551,7 +1562,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, const expr_t *expr) { unsigned char operator_type = 0; - unsigned char conftype = RPC_FC_NORMAL_CONFORMANCE; + unsigned char conftype = FC_NORMAL_CONFORMANCE; const char *conftype_string = "field"; const expr_t *subexpr; const type_t *iface = NULL; @@ -1571,7 +1582,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX); print_file(file, 2, "0x%x, /* Corr desc: constant, val = %d */\n", - RPC_FC_CONSTANT_CONFORMANCE, expr->cval); + FC_CONSTANT_CONFORMANCE, expr->cval); print_file(file, 2, "0x%x,\n", expr->cval >> 16); print_file(file, 2, "NdrFcShort(0x%hx),\n", (unsigned short)expr->cval); @@ -1580,7 +1591,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, if (!cont_type) /* top-level conformance */ { - conftype = RPC_FC_TOP_LEVEL_CONFORMANCE; + conftype = FC_TOP_LEVEL_CONFORMANCE; conftype_string = "parameter"; cont_type = current_func->type; name = current_func->name; @@ -1591,7 +1602,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, name = cont_type->name; if (is_ptr(type) || (is_array(type) && type_array_is_decl_as_ptr(type))) { - conftype = RPC_FC_POINTER_CONFORMANCE; + conftype = FC_POINTER_CONFORMANCE; conftype_string = "field pointer"; } } @@ -1601,34 +1612,34 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, { case EXPR_PPTR: subexpr = subexpr->ref; - operator_type = RPC_FC_DEREFERENCE; + operator_type = FC_DEREFERENCE; break; case EXPR_DIV: if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2)) { subexpr = subexpr->ref; - operator_type = RPC_FC_DIV_2; + operator_type = FC_DIV_2; } break; case EXPR_MUL: if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2)) { subexpr = subexpr->ref; - operator_type = RPC_FC_MULT_2; + operator_type = FC_MULT_2; } break; case EXPR_SUB: if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1)) { subexpr = subexpr->ref; - operator_type = RPC_FC_SUB_1; + operator_type = FC_SUB_1; } break; case EXPR_ADD: if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1)) { subexpr = subexpr->ref; - operator_type = RPC_FC_ADD_1; + operator_type = FC_ADD_1; } break; default: @@ -1687,26 +1698,26 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, { switch (get_basic_fc(correlation_variable)) { - case RPC_FC_CHAR: - case RPC_FC_SMALL: - param_type = RPC_FC_SMALL; + case FC_CHAR: + case FC_SMALL: + param_type = FC_SMALL; break; - case RPC_FC_BYTE: - case RPC_FC_USMALL: - param_type = RPC_FC_USMALL; + case FC_BYTE: + case FC_USMALL: + param_type = FC_USMALL; break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - param_type = RPC_FC_SHORT; + case FC_WCHAR: + case FC_SHORT: + param_type = FC_SHORT; break; - case RPC_FC_USHORT: - param_type = RPC_FC_USHORT; + case FC_USHORT: + param_type = FC_USHORT; break; - case RPC_FC_LONG: - param_type = RPC_FC_LONG; + case FC_LONG: + param_type = FC_LONG; break; - case RPC_FC_ULONG: - param_type = RPC_FC_ULONG; + case FC_ULONG: + param_type = FC_ULONG; break; default: error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n", @@ -1715,17 +1726,17 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, } else if (type_get_type(correlation_variable) == TYPE_ENUM) { - if (get_enum_fc(correlation_variable) == RPC_FC_ENUM32) - param_type = RPC_FC_LONG; + if (get_enum_fc(correlation_variable) == FC_ENUM32) + param_type = FC_LONG; else - param_type = RPC_FC_SHORT; + param_type = FC_SHORT; } else if (type_get_type(correlation_variable) == TYPE_POINTER) { if (pointer_size == 8) - param_type = RPC_FC_HYPER; + param_type = FC_HYPER; else - param_type = RPC_FC_LONG; + param_type = FC_LONG; } else { @@ -1776,7 +1787,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, error("Maximum number of callback routines reached\n"); print_file(file, 2, "0x%x,\t/* Corr desc: %s in %s */\n", conftype, conftype_string, name); - print_file(file, 2, "0x%x,\t/* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK"); + print_file(file, 2, "0x%x,\t/* %s */\n", FC_CALLBACK, "FC_CALLBACK"); print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)callback_offset, callback_offset); } else /* output a dummy corr desc that isn't used */ @@ -1841,7 +1852,7 @@ static unsigned int union_memsize(const var_list_t *fields, unsigned int *pmaxa) return maxs; } -static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align) +unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align) { unsigned int size = 0; @@ -1850,34 +1861,34 @@ static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *al case TYPE_BASIC: switch (get_basic_fc(t)) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_USMALL: - case RPC_FC_SMALL: + case FC_BYTE: + case FC_CHAR: + case FC_USMALL: + case FC_SMALL: size = 1; if (size > *align) *align = size; break; - case RPC_FC_WCHAR: - case RPC_FC_USHORT: - case RPC_FC_SHORT: + case FC_WCHAR: + case FC_USHORT: + case FC_SHORT: size = 2; if (size > *align) *align = size; break; - case RPC_FC_ULONG: - case RPC_FC_LONG: - case RPC_FC_ERROR_STATUS_T: - case RPC_FC_FLOAT: + case FC_ULONG: + case FC_LONG: + case FC_ERROR_STATUS_T: + case FC_FLOAT: size = 4; if (size > *align) *align = size; break; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: size = 8; if (size > *align) *align = size; break; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: - case RPC_FC_BIND_PRIMITIVE: + case FC_INT3264: + case FC_UINT3264: + case FC_BIND_PRIMITIVE: assert( pointer_size ); size = pointer_size; if (size > *align) *align = size; @@ -1890,8 +1901,8 @@ static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *al case TYPE_ENUM: switch (get_enum_fc(t)) { - case RPC_FC_ENUM16: - case RPC_FC_ENUM32: + case FC_ENUM16: + case FC_ENUM32: size = 4; if (size > *align) *align = size; break; @@ -1910,6 +1921,7 @@ static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *al size = union_memsize(type_union_get_cases(t), align); break; case TYPE_POINTER: + case TYPE_INTERFACE: assert( pointer_size ); size = pointer_size; if (size > *align) *align = size; @@ -1933,7 +1945,6 @@ static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *al if (size > *align) *align = size; } break; - case TYPE_INTERFACE: case TYPE_ALIAS: case TYPE_VOID: case TYPE_COCLASS: @@ -1967,24 +1978,24 @@ static unsigned int type_buffer_alignment(const type_t *t) case TYPE_BASIC: switch (get_basic_fc(t)) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_USMALL: - case RPC_FC_SMALL: + case FC_BYTE: + case FC_CHAR: + case FC_USMALL: + case FC_SMALL: return 1; - case RPC_FC_WCHAR: - case RPC_FC_USHORT: - case RPC_FC_SHORT: + case FC_WCHAR: + case FC_USHORT: + case FC_SHORT: return 2; - case RPC_FC_ULONG: - case RPC_FC_LONG: - case RPC_FC_ERROR_STATUS_T: - case RPC_FC_FLOAT: - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_ULONG: + case FC_LONG: + case FC_ERROR_STATUS_T: + case FC_FLOAT: + case FC_INT3264: + case FC_UINT3264: return 4; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: return 8; default: error("type_buffer_alignment: Unknown type 0x%x\n", get_basic_fc(t)); @@ -1993,9 +2004,9 @@ static unsigned int type_buffer_alignment(const type_t *t) case TYPE_ENUM: switch (get_enum_fc(t)) { - case RPC_FC_ENUM16: + case FC_ENUM16: return 2; - case RPC_FC_ENUM32: + case FC_ENUM32: return 4; default: error("type_buffer_alignment: Unknown enum type\n"); @@ -2094,14 +2105,38 @@ static unsigned int write_nonsimple_pointer(FILE *file, const attr_list_t *attrs out_attr = is_attr(attrs, ATTR_OUT); if (!in_attr && !out_attr) in_attr = 1; - if (out_attr && !in_attr && pointer_type == RPC_FC_RP) - flags |= RPC_FC_P_ONSTACK; + if (!is_interpreted_func(current_iface, current_func)) + { + if (out_attr && !in_attr && pointer_type == FC_RP) + flags |= FC_ALLOCED_ON_STACK; + } + else if (get_stub_mode() == MODE_Oif) + { + if (context == TYPE_CONTEXT_TOPLEVELPARAM && is_ptr(type) && pointer_type == FC_RP) + { + switch (typegen_detect_type(type_pointer_get_ref(type), NULL, TDT_ALL_TYPES)) + { + case TGT_STRING: + case TGT_POINTER: + case TGT_CTXT_HANDLE: + case TGT_CTXT_HANDLE_POINTER: + flags |= FC_ALLOCED_ON_STACK; + break; + case TGT_IFACE_POINTER: + if (in_attr && out_attr) + flags |= FC_ALLOCED_ON_STACK; + break; + default: + break; + } + } + } if (is_ptr(type)) { type_t *ref = type_pointer_get_ref(type); if(is_declptr(ref) && !is_user_type(ref)) - flags |= RPC_FC_P_DEREF; + flags |= FC_POINTER_DEREF; } print_file(file, 2, "0x%x, 0x%x,\t\t/* %s", @@ -2110,9 +2145,9 @@ static unsigned int write_nonsimple_pointer(FILE *file, const attr_list_t *attrs string_of_type(pointer_type)); if (file) { - if (flags & RPC_FC_P_ONSTACK) + if (flags & FC_ALLOCED_ON_STACK) fprintf(file, " [allocated_on_stack]"); - if (flags & RPC_FC_P_DEREF) + if (flags & FC_POINTER_DEREF) fprintf(file, " [pointer_deref]"); fprintf(file, " */\n"); } @@ -2131,7 +2166,7 @@ static unsigned int write_simple_pointer(FILE *file, const attr_list_t *attrs, const type_t *ref; int in_attr = is_attr(attrs, ATTR_IN); int out_attr = is_attr(attrs, ATTR_OUT); - unsigned char flags = RPC_FC_P_SIMPLEPOINTER; + unsigned char flags = FC_SIMPLE_POINTER; /* for historical reasons, write_simple_pointer also handled string types, * but no longer does. catch bad uses of the function with this check */ @@ -2146,12 +2181,20 @@ static unsigned int write_simple_pointer(FILE *file, const attr_list_t *attrs, else fc = get_basic_fc(ref); - if (out_attr && !in_attr) - flags |= RPC_FC_P_ONSTACK; + if (!is_interpreted_func(current_iface, current_func)) + { + if (out_attr && !in_attr && pointer_fc == FC_RP) + flags |= FC_ALLOCED_ON_STACK; + } + else if (get_stub_mode() == MODE_Oif) + { + if (context == TYPE_CONTEXT_TOPLEVELPARAM && fc == FC_ENUM16 && pointer_fc == FC_RP) + flags |= FC_ALLOCED_ON_STACK; + } print_file(file, 2, "0x%02x, 0x%x,\t/* %s %s[simple_pointer] */\n", pointer_fc, flags, string_of_type(pointer_fc), - flags & RPC_FC_P_ONSTACK ? "[allocated_on_stack] " : ""); + flags & FC_ALLOCED_ON_STACK ? "[allocated_on_stack] " : ""); print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc)); print_file(file, 2, "0x5c,\t/* FC_PAD */\n"); return 4; @@ -2203,10 +2246,10 @@ static int user_type_has_variable_size(const type_t *t) { switch (get_struct_fc(t)) { - case RPC_FC_PSTRUCT: - case RPC_FC_CSTRUCT: - case RPC_FC_CPSTRUCT: - case RPC_FC_CVSTRUCT: + case FC_PSTRUCT: + case FC_CSTRUCT: + case FC_CPSTRUCT: + case FC_CVSTRUCT: return TRUE; } } @@ -2255,9 +2298,9 @@ static unsigned int write_user_tfs(FILE *file, type_t *type, unsigned int *tfsof absoff = utype->typestring_offset; } - if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == RPC_FC_RP) + if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == FC_RP) flags = 0x40; - else if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == RPC_FC_UP) + else if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == FC_UP) flags = 0x80; else flags = 0; @@ -2265,7 +2308,7 @@ static unsigned int write_user_tfs(FILE *file, type_t *type, unsigned int *tfsof start = *tfsoff; update_tfsoff(type, start, file); print_start_tfs_comment(file, type, start); - print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", RPC_FC_USER_MARSHAL); + print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", FC_USER_MARSHAL); print_file(file, 2, "0x%x,\t/* Alignment= %d, Flags= %02x */\n", flags | (ualign - 1), ualign - 1, flags); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Function offset= %hu */\n", funoff, funoff); @@ -2310,7 +2353,7 @@ static void write_member_type(FILE *file, const type_t *cont, } else if (is_ptr(type) || is_conformant_array(type)) { - unsigned char fc = cont_is_complex ? RPC_FC_POINTER : RPC_FC_LONG; + unsigned char fc = cont_is_complex ? FC_POINTER : FC_LONG; print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc)); *tfsoff += 1; } @@ -2352,10 +2395,10 @@ static void write_end(FILE *file, unsigned int *tfsoff) { if (*tfsoff % 2 == 0) { - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); *tfsoff += 1; } - print_file(file, 2, "0x%x,\t/* FC_END */\n", RPC_FC_END); + print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END); *tfsoff += 1; } @@ -2377,8 +2420,8 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff) absoff += 8; /* we already have a corr descr, skip it */ reloff = absoff - (*tfsoff + 6); print_file(file, 0, "/* %d */\n", *tfsoff); - print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION); - print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", RPC_FC_LONG); + print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", FC_NON_ENCAPSULATED_UNION); + print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", FC_LONG); write_conf_or_var_desc(file, current_structure, offset, ft, get_attrp(f->attrs, ATTR_SWITCHIS)); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", @@ -2497,8 +2540,8 @@ static int write_no_repeat_pointer_descriptions( if (is_ptr(type) || (is_conformant_array(type) && type_array_is_decl_as_ptr(type))) { - print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", RPC_FC_NO_REPEAT); - print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", FC_NO_REPEAT); + print_file(file, 2, "0x%02x, /* FC_PAD */\n", FC_PAD); *typestring_offset += 2; return write_pointer_description_offsets(file, attrs, type, @@ -2561,8 +2604,8 @@ static int write_fixed_array_pointer_descriptions( increment_size = type_memsize(type_array_get_element(type)); - print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", RPC_FC_FIXED_REPEAT); - print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", FC_FIXED_REPEAT); + print_file(file, 2, "0x%02x, /* FC_PAD */\n", FC_PAD); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Iterations = %d */\n", (unsigned short)type_array_get_dim(type), type_array_get_dim(type)); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory); @@ -2635,8 +2678,8 @@ static int write_conformant_array_pointer_descriptions( if (increment_size > USHRT_MAX) error("array size of %u bytes is too large\n", increment_size); - print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT); - print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", RPC_FC_FIXED_OFFSET); + print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", FC_VARIABLE_REPEAT); + print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", FC_FIXED_OFFSET); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)offset_in_memory, offset_in_memory); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count); @@ -2677,8 +2720,8 @@ static int write_varying_array_pointer_descriptions( if (increment_size > USHRT_MAX) error("array size of %u bytes is too large\n", increment_size); - print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT); - print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", RPC_FC_VARIABLE_OFFSET); + print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", FC_VARIABLE_REPEAT); + print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", FC_VARIABLE_OFFSET); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count); @@ -2761,7 +2804,7 @@ static void write_pointer_description(FILE *file, const attr_list_t *attrs, type write_conformant_array_pointer_descriptions( file, attrs, type, 0, typestring_offset); else if (type_get_type(type) == TYPE_STRUCT && - get_struct_fc(type) == RPC_FC_CPSTRUCT) + get_struct_fc(type) == FC_CPSTRUCT) { type_t *carray = find_array_or_string_in_struct(type)->type; write_conformant_array_pointer_descriptions( file, NULL, carray, @@ -2789,10 +2832,10 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs, if (is_declptr(type)) { - unsigned char flag = is_conformant_array(type) ? 0 : RPC_FC_P_SIMPLEPOINTER; + unsigned char flag = is_conformant_array(type) ? 0 : FC_SIMPLE_POINTER; int pointer_type = get_pointer_fc_context(type, attrs, context); if (!pointer_type) - pointer_type = RPC_FC_RP; + pointer_type = FC_RP; print_start_tfs_comment(file, type, *typestring_offset); print_file(file, 2,"0x%x, 0x%x,\t/* %s%s */\n", pointer_type, flag, string_of_type(pointer_type), @@ -2821,7 +2864,7 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs, } rtype = get_basic_fc(elem_type); - if ((rtype != RPC_FC_BYTE) && (rtype != RPC_FC_CHAR) && (rtype != RPC_FC_WCHAR)) + if ((rtype != FC_BYTE) && (rtype != FC_CHAR) && (rtype != FC_WCHAR)) { error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", rtype, name); return start_offset; @@ -2838,11 +2881,11 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs, error("array size for parameter %s exceeds %u bytes by %u bytes\n", name, 0xffffu, dim - 0xffffu); - if (rtype == RPC_FC_WCHAR) + if (rtype == FC_WCHAR) WRITE_FCTYPE(file, FC_WSTRING, *typestring_offset); else WRITE_FCTYPE(file, FC_CSTRING, *typestring_offset); - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); *typestring_offset += 2; print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)dim, dim); @@ -2853,11 +2896,11 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs, } else if (is_conformant_array(type)) { - if (rtype == RPC_FC_WCHAR) + if (rtype == FC_WCHAR) WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset); else WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset); - print_file(file, 2, "0x%x,\t/* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED); + print_file(file, 2, "0x%x,\t/* FC_STRING_SIZED */\n", FC_STRING_SIZED); *typestring_offset += 2; *typestring_offset += write_conf_or_var_desc( @@ -2874,11 +2917,11 @@ static unsigned int write_string_tfs(FILE *file, const attr_list_t *attrs, { if (is_processed) return start_offset; - if (rtype == RPC_FC_WCHAR) + if (rtype == FC_WCHAR) WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset); else WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset); - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); *typestring_offset += 2; update_tfsoff(type, start_offset, file); @@ -2902,7 +2945,7 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t : 0; if (!pointer_type) - pointer_type = RPC_FC_RP; + pointer_type = FC_RP; if (!is_string_type(attrs, type_array_get_element(type))) write_embedded_types(file, attrs, type_array_get_element(type), name, FALSE, typestring_offset); @@ -2919,9 +2962,9 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *typestring_offset += 2; align = 0; - if (fc != RPC_FC_BOGUS_ARRAY) + if (fc != FC_BOGUS_ARRAY) { - if (fc == RPC_FC_LGFARRAY || fc == RPC_FC_LGVARRAY) + if (fc == FC_LGFARRAY || fc == FC_LGVARRAY) { print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", size, size); *typestring_offset += 4; @@ -2937,12 +2980,12 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t += write_conf_or_var_desc(file, current_structure, baseoff, type, size_is); - if (fc == RPC_FC_SMVARRAY || fc == RPC_FC_LGVARRAY) + if (fc == FC_SMVARRAY || fc == FC_LGVARRAY) { unsigned int elsize = type_memsize(type_array_get_element(type)); unsigned int dim = type_array_get_dim(type); - if (fc == RPC_FC_LGVARRAY) + if (fc == FC_LGVARRAY) { print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", dim, dim); *typestring_offset += 4; @@ -2965,11 +3008,11 @@ static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t if (type_has_pointers(type_array_get_element(type)) && (type_array_is_decl_as_ptr(type) || !current_structure)) { - print_file(file, 2, "0x%x,\t/* FC_PP */\n", RPC_FC_PP); - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%x,\t/* FC_PP */\n", FC_PP); + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); *typestring_offset += 2; write_pointer_description(file, is_string_type(attrs, type) ? attrs : NULL, type, typestring_offset); - print_file(file, 2, "0x%x,\t/* FC_END */\n", RPC_FC_END); + print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END); *typestring_offset += 1; } @@ -3042,13 +3085,13 @@ static void write_struct_members(FILE *file, const type_t *type, switch (align) { case 2: - fc = RPC_FC_ALIGNM2; + fc = FC_ALIGNM2; break; case 4: - fc = RPC_FC_ALIGNM4; + fc = FC_ALIGNM4; break; case 8: - fc = RPC_FC_ALIGNM8; + fc = FC_ALIGNM8; break; default: error("write_struct_members: cannot align type %d\n", type_get_type(ft)); @@ -3067,7 +3110,7 @@ static void write_struct_members(FILE *file, const type_t *type, if (padding) { print_file(file, 2, "0x%x,\t/* FC_STRUCTPAD%d */\n", - RPC_FC_STRUCTPAD1 + padding - 1, + FC_STRUCTPAD1 + padding - 1, padding); *typestring_offset += 1; } @@ -3130,13 +3173,13 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type, reloff, reloff, absoff); *tfsoff += 2; } - else if (fc == RPC_FC_BOGUS_STRUCT) + else if (fc == FC_BOGUS_STRUCT) { print_file(file, 2, "NdrFcShort(0x0),\n"); *tfsoff += 2; } - if (fc == RPC_FC_BOGUS_STRUCT) + if (fc == FC_BOGUS_STRUCT) { /* On the sizing pass, type->ptrdesc may be zero, but it's ok as nothing is written to file yet. On the actual writing pass, @@ -3148,22 +3191,22 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type, (unsigned short)reloff, reloff, absoff); *tfsoff += 2; } - else if ((fc == RPC_FC_PSTRUCT) || - (fc == RPC_FC_CPSTRUCT) || - (fc == RPC_FC_CVSTRUCT && type_has_pointers(type))) + else if ((fc == FC_PSTRUCT) || + (fc == FC_CPSTRUCT) || + (fc == FC_CVSTRUCT && type_has_pointers(type))) { - print_file(file, 2, "0x%x,\t/* FC_PP */\n", RPC_FC_PP); - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); + print_file(file, 2, "0x%x,\t/* FC_PP */\n", FC_PP); + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); *tfsoff += 2; write_pointer_description(file, NULL, type, tfsoff); - print_file(file, 2, "0x%x,\t/* FC_END */\n", RPC_FC_END); + print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END); *tfsoff += 1; } - write_struct_members(file, type, fc == RPC_FC_BOGUS_STRUCT, &corroff, + write_struct_members(file, type, fc == FC_BOGUS_STRUCT, &corroff, tfsoff); - if (fc == RPC_FC_BOGUS_STRUCT) + if (fc == FC_BOGUS_STRUCT) { const var_t *f; @@ -3248,6 +3291,7 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, unsigned int nbranch = 0; type_t *deftype = NULL; short nodeftype = 0xffff; + unsigned int dummy; var_t *f; if (processed(type) && @@ -3256,10 +3300,10 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, guard_rec(type); - size = type_memsize(type); - fields = type_union_get_cases(type); + size = union_memsize(fields, &dummy); + if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) { expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE); @@ -3276,6 +3320,7 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, { const var_t *sv = type_union_get_switch_value(type); const type_t *st = sv->type; + unsigned int align = 0; unsigned char fc; if (type_get_type(st) == TYPE_BASIC) @@ -3283,15 +3328,15 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, fc = get_basic_fc(st); switch (fc) { - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_BYTE: - case RPC_FC_USMALL: - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: - case RPC_FC_LONG: - case RPC_FC_ULONG: + case FC_CHAR: + case FC_SMALL: + case FC_BYTE: + case FC_USMALL: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: + case FC_LONG: + case FC_ULONG: break; default: fc = 0; @@ -3303,9 +3348,16 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, else error("union switch type must be an integer, char, or enum\n"); - print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", RPC_FC_ENCAPSULATED_UNION); + type_memsize_and_alignment(st, &align); + if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) + { + if (f->type) + type_memsize_and_alignment(f->type, &align); + } + + print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", FC_ENCAPSULATED_UNION); print_file(file, 2, "0x%x,\t/* Switch type= %s */\n", - 0x40 | fc, string_of_type(fc)); + (align << 4) | fc, string_of_type(fc)); *tfsoff += 2; } else if (is_attr(type->attrs, ATTR_SWITCHTYPE)) @@ -3319,15 +3371,15 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, fc = get_basic_fc(st); switch (fc) { - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: - case RPC_FC_SHORT: - case RPC_FC_USHORT: - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM16: - case RPC_FC_ENUM32: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: + case FC_SHORT: + case FC_USHORT: + case FC_LONG: + case FC_ULONG: + case FC_ENUM16: + case FC_ENUM32: break; default: fc = 0; @@ -3339,7 +3391,7 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, else error("union switch type must be an integer, char, or enum\n"); - print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION); + print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", FC_NON_ENCAPSULATED_UNION); print_file(file, 2, "0x%x,\t/* Switch type= %s */\n", fc, string_of_type(fc)); *tfsoff += 2; @@ -3453,21 +3505,21 @@ static unsigned int write_contexthandle_tfs(FILE *file, if (flags & 0x80) /* via ptr */ { int pointer_type = get_pointer_fc( type, attrs, toplevel_param ); - if (!pointer_type) pointer_type = RPC_FC_RP; + if (!pointer_type) pointer_type = FC_RP; *typeformat_offset += 4; print_file(file, 2,"0x%x, 0x0,\t/* %s */\n", pointer_type, string_of_type(pointer_type) ); print_file(file, 2, "NdrFcShort(0x2),\t /* Offset= 2 (%u) */\n", *typeformat_offset); print_file(file, 0, "/* %2u */\n", *typeformat_offset); } - print_file(file, 2, "0x%02x,\t/* FC_BIND_CONTEXT */\n", RPC_FC_BIND_CONTEXT); + print_file(file, 2, "0x%02x,\t/* FC_BIND_CONTEXT */\n", FC_BIND_CONTEXT); print_file(file, 2, "0x%x,\t/* Context flags: ", flags); /* return and can't be null values overlap */ if (((flags & 0x21) != 0x21) && (flags & NDR_CONTEXT_HANDLE_CANNOT_BE_NULL)) print_file(file, 0, "can't be null, "); if (flags & NDR_CONTEXT_HANDLE_SERIALIZE) print_file(file, 0, "serialize, "); - if (flags & NDR_CONTEXT_HANDLE_NO_SERIALIZE) + if (flags & NDR_CONTEXT_HANDLE_NOSERIALIZE) print_file(file, 0, "no serialize, "); if (flags & NDR_STRICT_CONTEXT_HANDLE) print_file(file, 0, "strict, "); @@ -3506,7 +3558,7 @@ static unsigned int write_range_tfs(FILE *file, const attr_list_t *attrs, assert(fc <= 0xf); print_file(file, 0, "/* %u */\n", *typeformat_offset); - print_file(file, 2, "0x%x,\t/* FC_RANGE */\n", RPC_FC_RANGE); + print_file(file, 2, "0x%x,\t/* FC_RANGE */\n", FC_RANGE); print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc)); print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", range_min->cval, range_min->cval); print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", range_max->cval, range_max->cval); @@ -3550,7 +3602,7 @@ static unsigned int write_type_tfs(FILE *file, int indent, int ptr_type; ptr_type = get_pointer_fc(type, attrs, context == TYPE_CONTEXT_TOPLEVELPARAM); - if (ptr_type != RPC_FC_RP || type_array_is_decl_as_ptr(type)) + if (ptr_type != FC_RP || type_array_is_decl_as_ptr(type)) { unsigned int absoff = type->typestring_offset; short reloff = absoff - (*typeformat_offset + 2); @@ -3560,7 +3612,7 @@ static unsigned int write_type_tfs(FILE *file, int indent, string_of_type(ptr_type)); print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", reloff, reloff, absoff); - if (ptr_type != RPC_FC_RP) update_tfsoff( type, off, file ); + if (ptr_type != FC_RP) update_tfsoff( type, off, file ); *typeformat_offset += 4; } type->details.array.ptr_tfsoff = off; @@ -3626,52 +3678,64 @@ static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *ty return write_type_tfs(file, 2, attrs, type, name, write_ptr ? TYPE_CONTEXT_CONTAINER : TYPE_CONTEXT_CONTAINER_NO_POINTERS, tfsoff); } -static unsigned int process_tfs_stmts(FILE *file, const statement_list_t *stmts, - type_pred_t pred, unsigned int *typeformat_offset) +static void process_tfs_iface(type_t *iface, FILE *file, int indent, unsigned int *offset) { - var_t *var; + const statement_list_t *stmts = type_iface_get_stmts(iface); const statement_t *stmt; + var_t *var; - if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) + current_iface = iface; + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry ) { - const type_t *iface; - const statement_t *stmt_func; - - if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) - continue; - - iface = stmt->u.type; - if (!pred(iface)) - continue; - - current_iface = iface; - STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(iface) ) + switch(stmt->type) { - const var_t *func = stmt_func->u.var; + case STMT_DECLARATION: + { + const var_t *func = stmt->u.var; + + if(stmt->u.var->stgclass != STG_NONE + || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION) + continue; + current_func = func; if (is_local(func->attrs)) continue; 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); + TYPE_CONTEXT_PARAM, offset); if (type_get_function_args(func->type)) 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 ); + TYPE_CONTEXT_TOPLEVELPARAM, offset ); + break; + + } + case STMT_TYPEDEF: + { + const type_list_t *type_entry; + for (type_entry = stmt->u.type_list; type_entry; type_entry = type_entry->next) + { + if (is_attr(type_entry->type->attrs, ATTR_ENCODE) + || is_attr(type_entry->type->attrs, ATTR_DECODE)) + type_entry->type->typestring_offset = write_type_tfs( file, 2, + type_entry->type->attrs, type_entry->type, type_entry->type->name, + TYPE_CONTEXT_CONTAINER, offset); + } + break; + } + default: + break; } } - - return *typeformat_offset + 1; } static unsigned int process_tfs(FILE *file, const statement_list_t *stmts, type_pred_t pred) { unsigned int typeformat_offset = 2; - - return process_tfs_stmts(file, stmts, pred, &typeformat_offset); + for_each_iface(stmts, process_tfs_iface, pred, file, 0, &typeformat_offset); + return typeformat_offset + 1; } @@ -3706,46 +3770,46 @@ static unsigned int get_required_buffer_size_type( { case TGT_USER_TYPE: { - const char *uname; + const char *uname = NULL; const type_t *utype = get_user_type(type, &uname); return get_required_buffer_size_type(utype, uname, NULL, FALSE, alignment); } case TGT_BASIC: switch (get_basic_fc(type)) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_USMALL: - case RPC_FC_SMALL: + case FC_BYTE: + case FC_CHAR: + case FC_USMALL: + case FC_SMALL: *alignment = 4; return 1; - case RPC_FC_WCHAR: - case RPC_FC_USHORT: - case RPC_FC_SHORT: + case FC_WCHAR: + case FC_USHORT: + case FC_SHORT: *alignment = 4; return 2; - case RPC_FC_ULONG: - case RPC_FC_LONG: - case RPC_FC_FLOAT: - case RPC_FC_ERROR_STATUS_T: + case FC_ULONG: + case FC_LONG: + case FC_FLOAT: + case FC_ERROR_STATUS_T: *alignment = 4; return 4; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: *alignment = 8; return 8; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: assert( pointer_size ); *alignment = pointer_size; return pointer_size; - case RPC_FC_IGNORE: - case RPC_FC_BIND_PRIMITIVE: + case FC_IGNORE: + case FC_BIND_PRIMITIVE: return 0; default: @@ -3758,17 +3822,17 @@ static unsigned int get_required_buffer_size_type( case TGT_ENUM: switch (get_enum_fc(type)) { - case RPC_FC_ENUM32: + case FC_ENUM32: *alignment = 4; return 4; - case RPC_FC_ENUM16: + case FC_ENUM16: *alignment = 4; return 2; } break; case TGT_STRUCT: - if (get_struct_fc(type) == RPC_FC_STRUCT) + if (get_struct_fc(type) == FC_STRUCT) { if (!type_struct_get_fields(type)) return 0; return fields_memsize(type_struct_get_fields(type), alignment); @@ -3781,7 +3845,7 @@ static unsigned int get_required_buffer_size_type( const type_t *ref = type_pointer_get_ref(type); if (is_string_type( attrs, ref )) break; if (!(size = get_required_buffer_size_type( ref, name, NULL, FALSE, &align ))) break; - if (get_pointer_fc(type, attrs, toplevel_param) != RPC_FC_RP) + if (get_pointer_fc(type, attrs, toplevel_param) != FC_RP) { size += 4 + align; align = 4; @@ -3791,12 +3855,12 @@ static unsigned int get_required_buffer_size_type( } case TGT_ARRAY: - if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_RP) + if (get_pointer_fc(type, attrs, toplevel_param) == FC_RP) { switch (get_array_fc(type)) { - case RPC_FC_SMFARRAY: - case RPC_FC_LGFARRAY: + case FC_SMFARRAY: + case FC_LGFARRAY: return type_array_get_dim(type) * get_required_buffer_size_type(type_array_get_element(type), name, NULL, FALSE, alignment); @@ -3938,36 +4002,36 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix, const type_t *ref = is_ptr(type) ? type_pointer_get_ref(type) : type; switch (get_basic_fc(ref)) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: alignment = 1; break; - case RPC_FC_WCHAR: - case RPC_FC_USHORT: - case RPC_FC_SHORT: + case FC_WCHAR: + case FC_USHORT: + case FC_SHORT: alignment = 2; break; - case RPC_FC_ULONG: - case RPC_FC_LONG: - case RPC_FC_FLOAT: - case RPC_FC_ERROR_STATUS_T: + case FC_ULONG: + case FC_LONG: + case FC_FLOAT: + case FC_ERROR_STATUS_T: /* pointer_size must be 4 if we got here in these two cases */ - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: alignment = 4; break; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: alignment = 8; break; - case RPC_FC_IGNORE: - case RPC_FC_BIND_PRIMITIVE: + case FC_IGNORE: + case FC_BIND_PRIMITIVE: /* no marshalling needed */ return; @@ -4201,14 +4265,14 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const break; case TGT_STRING: if (phase == PHASE_FREE || pass == PASS_RETURN || - pointer_type != RPC_FC_RP) + pointer_type != FC_RP) { /* strings returned are assumed to be global and hence don't * need freeing */ if (is_declptr(type) && !(phase == PHASE_FREE && pass == PASS_RETURN)) print_phase_function(file, indent, "Pointer", local_var_prefix, phase, var, start_offset); - else if (pointer_type == RPC_FC_RP && phase == PHASE_FREE && + else if (pointer_type == FC_RP && phase == PHASE_FREE && !in_attr && is_conformant_array(type)) { print_file(file, indent, "if (%s%s)\n", local_var_prefix, var->name); @@ -4250,34 +4314,34 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const switch (tc) { - case RPC_FC_SMFARRAY: - case RPC_FC_LGFARRAY: + case FC_SMFARRAY: + case FC_LGFARRAY: array_type = "FixedArray"; break; - case RPC_FC_SMVARRAY: - case RPC_FC_LGVARRAY: + case FC_SMVARRAY: + case FC_LGVARRAY: array_type = "VaryingArray"; break; - case RPC_FC_CARRAY: + case FC_CARRAY: array_type = "ConformantArray"; break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: array_type = "ConformantVaryingArray"; break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: array_type = "ComplexArray"; break; } - if (pointer_type != RPC_FC_RP) array_type = "Pointer"; + if (pointer_type != FC_RP) array_type = "Pointer"; - if (phase == PHASE_FREE && pointer_type == RPC_FC_RP) + if (phase == PHASE_FREE && pointer_type == FC_RP) { /* these are all unmarshalled by allocating memory */ - if (tc == RPC_FC_BOGUS_ARRAY || - tc == RPC_FC_CVARRAY || - ((tc == RPC_FC_SMVARRAY || tc == RPC_FC_LGVARRAY) && in_attr) || - (tc == RPC_FC_CARRAY && !in_attr)) + if (tc == FC_BOGUS_ARRAY || + tc == FC_CVARRAY || + ((tc == FC_SMVARRAY || tc == FC_LGVARRAY) && in_attr) || + (tc == FC_CARRAY && !in_attr)) { if (type_array_is_decl_as_ptr(type) && type->details.array.ptr_tfsoff) { @@ -4328,21 +4392,21 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const case TGT_STRUCT: switch (get_struct_fc(type)) { - case RPC_FC_STRUCT: + case FC_STRUCT: if (phase == PHASE_MARSHAL || phase == PHASE_UNMARSHAL) print_phase_function(file, indent, "SimpleStruct", local_var_prefix, phase, var, start_offset); break; - case RPC_FC_PSTRUCT: + case FC_PSTRUCT: print_phase_function(file, indent, "SimpleStruct", local_var_prefix, phase, var, start_offset); break; - case RPC_FC_CSTRUCT: - case RPC_FC_CPSTRUCT: + case FC_CSTRUCT: + case FC_CPSTRUCT: print_phase_function(file, indent, "ConformantStruct", local_var_prefix, phase, var, start_offset); break; - case RPC_FC_CVSTRUCT: + case FC_CVSTRUCT: print_phase_function(file, indent, "ConformantVaryingStruct", local_var_prefix, phase, var, start_offset); break; - case RPC_FC_BOGUS_STRUCT: + case FC_BOGUS_STRUCT: print_phase_function(file, indent, "ComplexStruct", local_var_prefix, phase, var, start_offset); break; default: @@ -4365,7 +4429,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const case TGT_POINTER: { const type_t *ref = type_pointer_get_ref(type); - if (pointer_type == RPC_FC_RP) switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES)) + if (pointer_type == FC_RP) switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES)) { case TGT_BASIC: print_phase_basetype(file, indent, local_var_prefix, phase, pass, var, var->name); @@ -4380,7 +4444,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const case TGT_STRUCT: switch (get_struct_fc(ref)) { - case RPC_FC_STRUCT: + case FC_STRUCT: /* simple structs have known sizes, so don't need a sizing * pass and don't have any memory to free and so don't * need a freeing pass */ @@ -4394,17 +4458,17 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const indent--; } break; - case RPC_FC_PSTRUCT: + case FC_PSTRUCT: type_str = "SimpleStruct"; break; - case RPC_FC_CSTRUCT: - case RPC_FC_CPSTRUCT: + case FC_CSTRUCT: + case FC_CPSTRUCT: type_str = "ConformantStruct"; break; - case RPC_FC_CVSTRUCT: + case FC_CVSTRUCT: type_str = "ConformantVaryingStruct"; break; - case RPC_FC_BOGUS_STRUCT: + case FC_BOGUS_STRUCT: type_str = "ComplexStruct"; break; default: @@ -4505,30 +4569,21 @@ unsigned int get_size_procformatstring_func(const type_t *iface, const var_t *fu return offset; } -unsigned int get_size_procformatstring(const statement_list_t *stmts, type_pred_t pred) +static void get_size_procformatstring_iface(type_t *iface, FILE *file, int indent, unsigned int *size) { const statement_t *stmt; - unsigned int size = 1; - - if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) + STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) { - const type_t *iface; - const statement_t *stmt_func; - - if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) - continue; - - iface = stmt->u.type; - if (!pred(iface)) - continue; - - STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(iface) ) - { - const var_t *func = stmt_func->u.var; - if (!is_local(func->attrs)) - size += get_size_procformatstring_func( iface, func ); - } + const var_t *func = stmt->u.var; + if (!is_local(func->attrs)) + *size += get_size_procformatstring_func( iface, func ); } +} + +unsigned int get_size_procformatstring(const statement_list_t *stmts, type_pred_t pred) +{ + unsigned int size = 1; + for_each_iface(stmts, get_size_procformatstring_iface, pred, NULL, 0, &size); return size; } diff --git a/sdk/tools/widl/typegen.h b/sdk/tools/widl/typegen.h index b6540e28c41..95ad601768d 100644 --- a/sdk/tools/widl/typegen.h +++ b/sdk/tools/widl/typegen.h @@ -100,3 +100,4 @@ unsigned char get_basic_fc(const type_t *type); unsigned char get_pointer_fc(const type_t *type, const attr_list_t *attrs, int toplevel_param); unsigned char get_struct_fc(const type_t *type); enum typegen_type typegen_detect_type(const type_t *type, const attr_list_t *attrs, unsigned int flags); +unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align); diff --git a/sdk/tools/widl/typelib.c b/sdk/tools/widl/typelib.c index 7c590bca49f..9411ccc545c 100644 --- a/sdk/tools/widl/typelib.c +++ b/sdk/tools/widl/typelib.c @@ -48,7 +48,9 @@ #include "typelib_struct.h" #include "typetree.h" +#ifdef __REACTOS__ static typelib_t *typelib; +#endif /* List of oleauto types that should be recognized by name. * (most of) these seem to be intrinsic types in mktyplib. @@ -161,6 +163,7 @@ unsigned short get_type_vt(type_t *t) else return VT_INT; case TYPE_BASIC_INT32: + case TYPE_BASIC_LONG: case TYPE_BASIC_ERROR_STATUS_T: if (type_basic_get_sign(t) > 0) return VT_UI4; @@ -173,7 +176,7 @@ unsigned short get_type_vt(type_t *t) else return VT_I8; case TYPE_BASIC_INT3264: - if (typelib_kind == SYS_WIN64) + if (pointer_size == 8) { if (type_basic_get_sign(t) > 0) return VT_UI8; @@ -204,10 +207,10 @@ unsigned short get_type_vt(type_t *t) { if (match(type_array_get_element(t)->name, "SAFEARRAY")) return VT_SAFEARRAY; + return VT_PTR; } else - error("get_type_vt: array types not supported\n"); - return VT_PTR; + return VT_CARRAY; case TYPE_INTERFACE: if(match(t->name, "IUnknown")) @@ -243,6 +246,7 @@ unsigned short get_type_vt(type_t *t) return 0; } +#ifdef __REACTOS__ void start_typelib(typelib_t *typelib_type) { if (!do_typelib) return; @@ -253,11 +257,9 @@ void end_typelib(void) { if (!typelib) return; - if (do_old_typelib) - create_sltg_typelib(typelib); - else - create_msft_typelib(typelib); + create_msft_typelib(typelib); } +#endif static void tlb_read(int fd, void *buf, int count) { @@ -383,7 +385,11 @@ static void read_importlib(importlib_t *importlib) close(fd); } +#ifdef __REACTOS__ void add_importlib(const char *name) +#else +void add_importlib(const char *name, typelib_t *typelib) +#endif { importlib_t *importlib; diff --git a/sdk/tools/widl/typelib.h b/sdk/tools/widl/typelib.h index 31f4a5a859f..8c7303ca6b3 100644 --- a/sdk/tools/widl/typelib.h +++ b/sdk/tools/widl/typelib.h @@ -21,9 +21,13 @@ #ifndef __WIDL_TYPELIB_H #define __WIDL_TYPELIB_H +#ifdef __REACTOS__ extern void start_typelib(typelib_t *typelib_type); extern void end_typelib(void); extern void add_importlib(const char *name); +#else +extern void add_importlib(const char *name, typelib_t *typelib); +#endif /* Copied from wtypes.h. Not included directly because that would create a * circular dependency (after all, wtypes.h is generated by widl...) */ diff --git a/sdk/tools/widl/typetree.c b/sdk/tools/widl/typetree.c index e3166145b6a..b93806be981 100644 --- a/sdk/tools/widl/typetree.c +++ b/sdk/tools/widl/typetree.c @@ -377,6 +377,7 @@ static int is_valid_bitfield_type(const type_t *type) case TYPE_BASIC_INT64: case TYPE_BASIC_INT: case TYPE_BASIC_INT3264: + case TYPE_BASIC_LONG: case TYPE_BASIC_CHAR: case TYPE_BASIC_HYPER: case TYPE_BASIC_BYTE: @@ -442,6 +443,8 @@ void type_interface_define(type_t *iface, type_t *inherit, statement_list_t *stm iface->details.iface->disp_methods = NULL; iface->details.iface->stmts = stmts; iface->details.iface->inherit = inherit; + iface->details.iface->disp_inherit = NULL; + iface->details.iface->async_iface = NULL; iface->defined = TRUE; compute_method_indexes(iface); } @@ -454,14 +457,24 @@ void type_dispinterface_define(type_t *iface, var_list_t *props, var_list_t *met iface->details.iface->stmts = NULL; iface->details.iface->inherit = find_type("IDispatch", NULL, 0); if (!iface->details.iface->inherit) error_loc("IDispatch is undefined\n"); + iface->details.iface->disp_inherit = NULL; + iface->details.iface->async_iface = NULL; iface->defined = TRUE; compute_method_indexes(iface); } void type_dispinterface_define_from_iface(type_t *dispiface, type_t *iface) { - type_dispinterface_define(dispiface, iface->details.iface->disp_props, - iface->details.iface->disp_methods); + dispiface->details.iface = xmalloc(sizeof(*dispiface->details.iface)); + dispiface->details.iface->disp_props = NULL; + dispiface->details.iface->disp_methods = NULL; + dispiface->details.iface->stmts = NULL; + dispiface->details.iface->inherit = find_type("IDispatch", NULL, 0); + if (!dispiface->details.iface->inherit) error_loc("IDispatch is undefined\n"); + dispiface->details.iface->disp_inherit = iface; + dispiface->details.iface->async_iface = NULL; + dispiface->defined = TRUE; + compute_method_indexes(dispiface); } void type_module_define(type_t *module, statement_list_t *stmts) diff --git a/sdk/tools/widl/typetree.h b/sdk/tools/widl/typetree.h index bf05f259511..fc134cd575d 100644 --- a/sdk/tools/widl/typetree.h +++ b/sdk/tools/widl/typetree.h @@ -176,6 +176,13 @@ static inline var_list_t *type_dispiface_get_methods(const type_t *type) return type->details.iface->disp_methods; } +static inline type_t *type_dispiface_get_inherit(const type_t *type) +{ + type = type_get_real_type(type); + assert(type_get_type(type) == TYPE_INTERFACE); + return type->details.iface->disp_inherit; +} + static inline int type_is_defined(const type_t *type) { return type->defined; diff --git a/sdk/tools/widl/widl.c b/sdk/tools/widl/widl.c index 4b051ef36ea..77d4b7750a9 100644 --- a/sdk/tools/widl/widl.c +++ b/sdk/tools/widl/widl.c @@ -43,14 +43,10 @@ #include "wine/wpp.h" #include "header.h" -/* future options to reserve characters for: */ -/* A = ACF input filename */ -/* J = do not search standard include path */ -/* w = select win16/win32 output (?) */ - static const char usage[] = "Usage: widl [options...] infile.idl\n" " or: widl [options...] --dlldata-only name1 [name2...]\n" +" --acf=file Use ACF file\n" " -app_config Ignored, present for midl compatibility\n" " -b arch Set the target architecture\n" " -c Generate client stub\n" @@ -62,7 +58,7 @@ static const char usage[] = " -H file Name of header file (default is infile.h)\n" " -I path Set include search dir to path (multiple -I allowed)\n" " --local-stubs=file Write empty stubs for call_as/local methods to file\n" -" -m32, -m64 Set the kind of typelib to build (Win32 or Win64)\n" +" -m32, -m64 Set the target architecture (Win32 or Win64)\n" " -N Do not preprocess input\n" " --oldnames Use old naming conventions\n" " --oldtlb Use old typelib (SLTG) format\n" @@ -73,6 +69,7 @@ static const char usage[] = " --prefix-client=p Prefix names of client stubs with 'p'\n" " --prefix-server=p Prefix names of server functions with 'p'\n" " -r Generate registration script\n" +" -robust Ignored, present for midl compatibility\n" " --winrt Enable Windows Runtime mode\n" " --ns_prefix Prefix namespaces with ABI namespace\n" " -s Generate server stub\n" @@ -80,8 +77,7 @@ static const char usage[] = " -u Generate interface identifiers file\n" " -V Print version and exit\n" " -W Enable pedantic warnings\n" -" --win32 Only generate 32-bit code\n" -" --win64 Only generate 64-bit code\n" +" --win32, --win64 Set the target architecture (Win32 or Win64)\n" " --win32-align n Set win32 structure alignment to 'n'\n" " --win64-align n Set win64 structure alignment to 'n'\n" "Debug level 'n' is a bitmask with following meaning:\n" @@ -96,6 +92,20 @@ static const char usage[] = static const char version_string[] = "Wine IDL Compiler version " PACKAGE_VERSION "\n" "Copyright 2002 Ove Kaaven\n"; +#ifdef __i386__ +enum target_cpu target_cpu = CPU_x86; +#elif defined(__x86_64__) +enum target_cpu target_cpu = CPU_x86_64; +#elif defined(__powerpc__) +enum target_cpu target_cpu = CPU_POWERPC; +#elif defined(__arm__) +enum target_cpu target_cpu = CPU_ARM; +#elif defined(__aarch64__) +enum target_cpu target_cpu = CPU_ARM64; +#else +#error Unsupported CPU +#endif + int debuglevel = DEBUGLEVEL_NONE; int parser_debug, yy_flex_debug; @@ -113,8 +123,6 @@ int do_idfile = 0; int do_dlldata = 0; static int no_preprocess = 0; int old_names = 0; -int do_win32 = 1; -int do_win64 = 1; int win32_packing = 8; int win64_packing = 8; int winrt_mode = 0; @@ -123,6 +131,7 @@ static enum stub_mode stub_mode = MODE_Os; char *input_name; char *input_idl_name; +char *acf_name; char *header_name; char *local_stubs_name; char *header_token; @@ -146,49 +155,53 @@ int line_number = 1; static FILE *idfile; unsigned int pointer_size = 0; -syskind_t typelib_kind = sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32; time_t now; enum { OLDNAMES_OPTION = CHAR_MAX + 1, + ACF_OPTION, + APP_CONFIG_OPTION, DLLDATA_OPTION, DLLDATA_ONLY_OPTION, LOCAL_STUBS_OPTION, + OLD_TYPELIB_OPTION, PREFIX_ALL_OPTION, PREFIX_CLIENT_OPTION, PREFIX_SERVER_OPTION, PRINT_HELP, RT_NS_PREFIX, RT_OPTION, + ROBUST_OPTION, WIN32_OPTION, WIN64_OPTION, WIN32_ALIGN_OPTION, - WIN64_ALIGN_OPTION, - APP_CONFIG_OPTION, - OLD_TYPELIB_OPTION + WIN64_ALIGN_OPTION }; static const char short_options[] = "b:cC:d:D:EhH:I:m:No:O:pP:rsS:tT:uU:VW"; static const struct option long_options[] = { + { "acf", 1, NULL, ACF_OPTION }, + { "app_config", 0, NULL, APP_CONFIG_OPTION }, { "dlldata", 1, NULL, DLLDATA_OPTION }, { "dlldata-only", 0, NULL, DLLDATA_ONLY_OPTION }, { "help", 0, NULL, PRINT_HELP }, { "local-stubs", 1, NULL, LOCAL_STUBS_OPTION }, { "ns_prefix", 0, NULL, RT_NS_PREFIX }, { "oldnames", 0, NULL, OLDNAMES_OPTION }, + { "oldtlb", 0, NULL, OLD_TYPELIB_OPTION }, { "output", 0, NULL, 'o' }, { "prefix-all", 1, NULL, PREFIX_ALL_OPTION }, { "prefix-client", 1, NULL, PREFIX_CLIENT_OPTION }, { "prefix-server", 1, NULL, PREFIX_SERVER_OPTION }, + { "robust", 0, NULL, ROBUST_OPTION }, + { "target", 0, NULL, 'b' }, { "winrt", 0, NULL, RT_OPTION }, { "win32", 0, NULL, WIN32_OPTION }, { "win64", 0, NULL, WIN64_OPTION }, { "win32-align", 1, NULL, WIN32_ALIGN_OPTION }, { "win64-align", 1, NULL, WIN64_ALIGN_OPTION }, - { "app_config", 0, NULL, APP_CONFIG_OPTION }, - { "oldtlb", 0, NULL, OLD_TYPELIB_OPTION }, { NULL, 0, NULL, 0 } }; @@ -265,20 +278,24 @@ static void set_target( const char *target ) { static const struct { - const char *name; - syskind_t kind; + const char *name; + enum target_cpu cpu; } cpu_names[] = { - { "i386", SYS_WIN32 }, - { "i486", SYS_WIN32 }, - { "i586", SYS_WIN32 }, - { "i686", SYS_WIN32 }, - { "i786", SYS_WIN32 }, - { "amd64", SYS_WIN64 }, - { "x86_64", SYS_WIN64 }, - { "powerpc", SYS_WIN32 }, - { "arm", SYS_WIN32 }, - { "aarch64", SYS_WIN64 } + { "i386", CPU_x86 }, + { "i486", CPU_x86 }, + { "i586", CPU_x86 }, + { "i686", CPU_x86 }, + { "i786", CPU_x86 }, + { "amd64", CPU_x86_64 }, + { "x86_64", CPU_x86_64 }, + { "powerpc", CPU_POWERPC }, + { "arm", CPU_ARM }, + { "armv5", CPU_ARM }, + { "armv6", CPU_ARM }, + { "armv7", CPU_ARM }, + { "arm64", CPU_ARM64 }, + { "aarch64", CPU_ARM64 }, }; unsigned int i; @@ -292,7 +309,7 @@ static void set_target( const char *target ) { if (!strcmp( cpu_names[i].name, spec )) { - typelib_kind = cpu_names[i].kind; + target_cpu = cpu_names[i].cpu; free( spec ); return; } @@ -487,6 +504,11 @@ static void write_id_data_stmts(const statement_list_t *stmts) uuid = get_attrp(type->attrs, ATTR_UUID); write_id_guid(idfile, "IID", is_attr(type->attrs, ATTR_DISPINTERFACE) ? "DIID" : "IID", type->name, uuid); + if (type->details.iface->async_iface) + { + uuid = get_attrp(type->details.iface->async_iface->attrs, ATTR_UUID); + write_id_guid(idfile, "IID", "IID", type->details.iface->async_iface->name, uuid); + } } else if (type_get_type(type) == TYPE_COCLASS) { @@ -537,10 +559,15 @@ void write_id_data(const statement_list_t *stmts) fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n"); fprintf(idfile, " DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8)\n\n"); + fprintf(idfile, "#elif defined(__cplusplus)\n\n"); + + fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n"); + fprintf(idfile, " EXTERN_C const type DECLSPEC_SELECTANY name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n"); + fprintf(idfile, "#else\n\n"); fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n"); - fprintf(idfile, " const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n"); + fprintf(idfile, " const type DECLSPEC_SELECTANY name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n"); fprintf(idfile, "#endif\n\n"); start_cplusplus_guard(idfile); @@ -605,12 +632,10 @@ int main(int argc,char *argv[]) use_abi_namespace = 1; break; case WIN32_OPTION: - do_win32 = 1; - do_win64 = 0; + pointer_size = 4; break; case WIN64_OPTION: - do_win32 = 0; - do_win64 = 1; + pointer_size = 8; break; case WIN32_ALIGN_OPTION: win32_packing = strtol(optarg, NULL, 0); @@ -622,9 +647,15 @@ int main(int argc,char *argv[]) if(win64_packing != 2 && win64_packing != 4 && win64_packing != 8) error("Packing must be one of 2, 4 or 8\n"); break; + case ACF_OPTION: + acf_name = xstrdup(optarg); + break; case APP_CONFIG_OPTION: /* widl does not distinguish between app_mode and default mode, but we ignore this option for midl compatibility */ + break; + case ROBUST_OPTION: + /* FIXME: Support robust option */ break; case 'b': set_target( optarg ); @@ -657,8 +688,8 @@ int main(int argc,char *argv[]) wpp_add_include_path(optarg); break; case 'm': - if (!strcmp( optarg, "32" )) typelib_kind = SYS_WIN32; - else if (!strcmp( optarg, "64" )) typelib_kind = SYS_WIN64; + if (!strcmp( optarg, "32" )) pointer_size = 4; + else if (!strcmp( optarg, "64" )) pointer_size = 8; break; case 'N': no_preprocess = 1; @@ -725,6 +756,26 @@ int main(int argc,char *argv[]) wpp_add_include_path(DEFAULT_INCLUDE_DIR); #endif + switch (target_cpu) + { + case CPU_x86: + if (pointer_size == 8) target_cpu = CPU_x86_64; + else pointer_size = 4; + break; + case CPU_x86_64: + if (pointer_size == 4) target_cpu = CPU_x86; + else pointer_size = 8; + break; + case CPU_ARM64: + if (pointer_size == 4) error( "Cannot build 32-bit code for this CPU\n" ); + pointer_size = 8; + break; + default: + if (pointer_size == 8) error( "Cannot build 64-bit code for this CPU\n" ); + pointer_size = 4; + break; + } + /* if nothing specified, try to guess output type from the output file name */ if (output_name && do_everything && !do_header && !do_typelib && !do_proxies && !do_client && !do_server && !do_regscript && !do_idfile && !do_dlldata) diff --git a/sdk/tools/widl/widl.h b/sdk/tools/widl/widl.h index 90b63661d2f..c015ec01384 100644 --- a/sdk/tools/widl/widl.h +++ b/sdk/tools/widl/widl.h @@ -46,8 +46,6 @@ extern int do_regscript; extern int do_idfile; extern int do_dlldata; extern int old_names; -extern int do_win32; -extern int do_win64; extern int win32_packing; extern int win64_packing; extern int winrt_mode; @@ -55,6 +53,7 @@ extern int use_abi_namespace; extern char *input_name; extern char *input_idl_name; +extern char *acf_name; extern char *header_name; extern char *header_token; extern char *local_stubs_name; @@ -76,6 +75,13 @@ extern time_t now; extern int line_number; extern int char_number; +enum target_cpu +{ + CPU_x86, CPU_x86_64, CPU_POWERPC, CPU_ARM, CPU_ARM64, CPU_LAST = CPU_ARM64 +}; + +extern enum target_cpu target_cpu; + enum stub_mode { MODE_Os, /* inline stubs */ @@ -90,6 +96,9 @@ extern void write_proxies(const statement_list_t *stmts); extern void write_client(const statement_list_t *stmts); extern void write_server(const statement_list_t *stmts); extern void write_regscript(const statement_list_t *stmts); +#ifndef __REACTOS__ +extern void write_typelib_regscript(const statement_list_t *stmts); +#endif extern void output_typelib_regscript( const typelib_t *typelib ); extern void write_local_stubs(const statement_list_t *stmts); extern void write_dlldata(const statement_list_t *stmts); diff --git a/sdk/tools/widl/widltypes.h b/sdk/tools/widl/widltypes.h index 1f4a9dd10f3..37792b24895 100644 --- a/sdk/tools/widl/widltypes.h +++ b/sdk/tools/widl/widltypes.h @@ -24,7 +24,7 @@ #include #include #include "guiddef.h" -#include "wine/rpcfc.h" +#include "ndrtypes.h" #include "wine/list.h" #ifndef UUID_DEFINED @@ -59,7 +59,6 @@ typedef struct list expr_list_t; typedef struct list var_list_t; typedef struct list declarator_list_t; typedef struct list ifref_list_t; -typedef struct list array_dims_t; typedef struct list user_type_list_t; typedef struct list context_handle_list_t; typedef struct list generic_handle_list_t; @@ -266,6 +265,7 @@ enum type_basic_type TYPE_BASIC_INT64, TYPE_BASIC_INT, TYPE_BASIC_INT3264, + TYPE_BASIC_LONG, TYPE_BASIC_CHAR, TYPE_BASIC_HYPER, TYPE_BASIC_BYTE, @@ -343,6 +343,8 @@ struct iface_details var_list_t *disp_methods; var_list_t *disp_props; struct _type_t *inherit; + struct _type_t *disp_inherit; + struct _type_t *async_iface; }; struct module_details @@ -464,7 +466,6 @@ struct _declarator_t { var_t *var; type_t *type; type_t *func_type; - array_dims_t *array; expr_t *bits; /* parser-internal */ @@ -552,7 +553,6 @@ typedef enum { SYS_WIN64 } syskind_t; -extern syskind_t typelib_kind; extern user_type_list_t user_type_list; extern context_handle_list_t context_handle_list; extern generic_handle_list_t generic_handle_list; diff --git a/sdk/tools/widl/write_msft.c b/sdk/tools/widl/write_msft.c index efaa633f2f7..2fa7e193619 100644 --- a/sdk/tools/widl/write_msft.c +++ b/sdk/tools/widl/write_msft.c @@ -57,6 +57,7 @@ #include "hash.h" #include "typetree.h" #include "parser.h" +#include "typegen.h" #ifdef __REACTOS__ #define S_OK 0 @@ -791,8 +792,6 @@ static int encode_type( int vt, /* [I] vt to encode */ type_t *type, /* [I] type */ int *encoded_type, /* [O] The encoded type description. */ - int *width, /* [O] The width of the type, or NULL. */ - int *alignment, /* [O] The alignment of the type, or NULL. */ int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */ { int default_type; @@ -805,8 +804,6 @@ static int encode_type( chat("encode_type vt %d type %p\n", vt, type); default_type = 0x80000000 | (vt << 16) | vt; - if (!width) width = &scratch; - if (!alignment) alignment = &scratch; if (!decoded_size) decoded_size = &scratch; *decoded_size = 0; @@ -815,38 +812,20 @@ static int encode_type( case VT_I1: case VT_UI1: *encoded_type = default_type; - *width = 1; - *alignment = 1; break; case VT_INT: *encoded_type = 0x80000000 | (VT_I4 << 16) | VT_INT; - if ((typelib->typelib_header.varflags & 0x0f) == SYS_WIN16) { - *width = 2; - *alignment = 2; - } else { - *width = 4; - *alignment = 4; - } break; case VT_UINT: *encoded_type = 0x80000000 | (VT_UI4 << 16) | VT_UINT; - if ((typelib->typelib_header.varflags & 0x0f) == SYS_WIN16) { - *width = 2; - *alignment = 2; - } else { - *width = 4; - *alignment = 4; - } break; case VT_UI2: case VT_I2: case VT_BOOL: *encoded_type = default_type; - *width = 2; - *alignment = 2; break; case VT_I4: @@ -855,56 +834,40 @@ static int encode_type( case VT_ERROR: case VT_HRESULT: *encoded_type = default_type; - *width = 4; - *alignment = 4; break; case VT_R8: case VT_I8: case VT_UI8: *encoded_type = default_type; - *width = 8; - *alignment = 8; break; case VT_CY: case VT_DATE: *encoded_type = default_type; - *width = 8; - *alignment = 8; break; case VT_DECIMAL: *encoded_type = default_type; - *width = 16; - *alignment = 8; break; case VT_VOID: *encoded_type = 0x80000000 | (VT_EMPTY << 16) | vt; - *width = 0; - *alignment = 1; break; case VT_UNKNOWN: case VT_DISPATCH: case VT_BSTR: *encoded_type = default_type; - *width = pointer_size; - *alignment = 4; break; case VT_VARIANT: *encoded_type = default_type; - *width = 8 + 2 * pointer_size; - *alignment = 8; break; case VT_LPSTR: case VT_LPWSTR: *encoded_type = 0xfffe0000 | vt; - *width = pointer_size; - *alignment = 4; break; case VT_PTR: @@ -920,14 +883,12 @@ static int encode_type( next_vt = VT_VOID; encode_type(typelib, next_vt, type_pointer_get_ref(type), - &target_type, NULL, NULL, &child_size); + &target_type, &child_size); /* these types already have an implicit pointer, so we don't need to * add another */ if(next_vt == VT_DISPATCH || next_vt == VT_UNKNOWN) { chat("encode_type: skipping ptr\n"); *encoded_type = target_type; - *width = pointer_size; - *alignment = 4; *decoded_size = child_size; break; } @@ -956,8 +917,6 @@ static int encode_type( *encoded_type = typeoffset; - *width = pointer_size; - *alignment = 4; *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size; break; } @@ -967,7 +926,8 @@ static int encode_type( type_t *element_type = type_alias_get_aliasee(type_array_get_element(type)); int next_vt = get_type_vt(element_type); - encode_type(typelib, next_vt, type_alias_get_aliasee(type_array_get_element(type)), &target_type, NULL, NULL, &child_size); + encode_type(typelib, next_vt, type_alias_get_aliasee(type_array_get_element(type)), + &target_type, &child_size); for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) { typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset]; @@ -993,26 +953,39 @@ static int encode_type( *encoded_type = typeoffset; - *width = pointer_size; - *alignment = 4; *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size; break; } case VT_USERDEFINED: { + importinfo_t *importinfo; int typeinfo_offset; - /* typedef'd types without public attribute aren't included in the typelib */ - while (type->typelib_idx < 0 && type_is_alias(type) && !is_attr(type->attrs, ATTR_PUBLIC)) - type = type_alias_get_aliasee(type); + if (type->typelib_idx > -1) + { + chat("encode_type: VT_USERDEFINED - found already defined type %s at %d\n", + type->name, type->typelib_idx); + typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx]; + } + else if ((importinfo = find_importinfo(typelib, type->name))) + { + chat("encode_type: VT_USERDEFINED - found imported type %s in %s\n", + type->name, importinfo->importlib->name); + alloc_importinfo(typelib, importinfo); + typeinfo_offset = importinfo->offset | 0x1; + } + else + { + /* typedef'd types without public attribute aren't included in the typelib */ + while (type_is_alias(type) && !is_attr(type->attrs, ATTR_PUBLIC)) + type = type_alias_get_aliasee(type); - chat("encode_type: VT_USERDEFINED - type %p name = %s real type %d idx %d\n", type, - type->name, type_get_type(type), type->typelib_idx); + chat("encode_type: VT_USERDEFINED - adding new type %s, real type %d\n", + type->name, type_get_type(type)); - if(type->typelib_idx == -1) { - chat("encode_type: trying to ref not added type\n"); - switch (type_get_type(type)) { + switch (type_get_type(type)) + { case TYPE_STRUCT: add_structure_typeinfo(typelib, type); break; @@ -1032,9 +1005,9 @@ static int encode_type( error("encode_type: VT_USERDEFINED - unhandled type %d\n", type_get_type(type)); } - } - typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx]; + typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx]; + } for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) { typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset]; if ((typedata[0] == ((0x7fff << 16) | VT_USERDEFINED)) && (typedata[1] == typeinfo_offset)) break; @@ -1049,16 +1022,12 @@ static int encode_type( } *encoded_type = typeoffset; - *width = 0; - *alignment = 1; break; } default: error("encode_type: unrecognized type %d.\n", vt); *encoded_type = default_type; - *width = 0; - *alignment = 1; break; } @@ -1075,8 +1044,6 @@ static int encode_var( type_t *type, /* [I] The type description to encode. */ var_t *var, /* [I] The var to encode. */ int *encoded_type, /* [O] The encoded type description. */ - int *width, /* [O] The width of the type, or NULL. */ - int *alignment, /* [O] The alignment of the type, or NULL. */ int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */ { int typeoffset; @@ -1086,8 +1053,6 @@ static int encode_var( int vt; int scratch; - if (!width) width = &scratch; - if (!alignment) alignment = &scratch; if (!decoded_size) decoded_size = &scratch; *decoded_size = 0; @@ -1106,7 +1071,7 @@ static int encode_var( ++num_dims; chat("array with %d dimensions\n", num_dims); - encode_var(typelib, atype, var, &target_type, width, alignment, NULL); + encode_var(typelib, atype, var, &target_type, NULL); arrayoffset = ctl2_alloc_segment(typelib, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(int), 0); arraydata = (void *)&typelib->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset]; @@ -1132,7 +1097,6 @@ static int encode_var( typedata[1] = arrayoffset; *encoded_type = typeoffset; - *width = *width * elements; *decoded_size = 20 /*sizeof(ARRAYDESC)*/ + (num_dims - 1) * 8 /*sizeof(SAFEARRAYBOUND)*/; return 0; } @@ -1141,15 +1105,12 @@ static int encode_var( if (vt == VT_PTR) { type_t *ref = is_ptr(type) ? type_pointer_get_ref(type) : type_array_get_element(type); - int skip_ptr = encode_var(typelib, ref, var, - &target_type, NULL, NULL, &child_size); + int skip_ptr = encode_var(typelib, ref, var, &target_type, &child_size); if(skip_ptr == 2) { chat("encode_var: skipping ptr\n"); *encoded_type = target_type; *decoded_size = child_size; - *width = pointer_size; - *alignment = 4; return 0; } @@ -1163,7 +1124,7 @@ static int encode_var( if (target_type & 0x80000000) { mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF; - } else if (is_array(ref)) { + } else if (get_type_vt(ref) == VT_SAFEARRAY) { type_t *element_type = type_alias_get_aliasee(type_array_get_element(ref)); mix_field = get_type_vt(element_type) | VT_ARRAY | VT_BYREF; } else { @@ -1180,15 +1141,13 @@ static int encode_var( *encoded_type = typeoffset; - *width = pointer_size; - *alignment = 4; *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size; return 0; } dump_type(type); - encode_type(typelib, vt, type, encoded_type, width, alignment, decoded_size); + encode_type(typelib, vt, type, encoded_type, decoded_size); /* these types already have an implicit pointer, so we don't need to * add another */ if(vt == VT_DISPATCH || vt == VT_UNKNOWN) return 2; @@ -1210,59 +1169,79 @@ static unsigned int get_ulong_val(unsigned int val, int vt) return val; } -static void write_value(msft_typelib_t* typelib, int *out, int vt, const void *value) +static void write_int_value(msft_typelib_t *typelib, int *out, int vt, int value) { - switch(vt) { - case VT_I2: - case VT_I4: - case VT_R4: - case VT_BOOL: - case VT_I1: - case VT_UI1: - case VT_UI2: - case VT_UI4: - case VT_INT: - case VT_UINT: - case VT_HRESULT: - case VT_PTR: - case VT_UNKNOWN: - case VT_DISPATCH: - { - const unsigned int lv = get_ulong_val(*(const unsigned int *)value, vt); - if((lv & 0x3ffffff) == lv) { - *out = 0x80000000; - *out |= vt << 26; - *out |= lv; - } else { - int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, 8, 0); - *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt; - memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], value, 4); - *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6]) = 0x5757; - *out = offset; - } - return; - } - case VT_BSTR: - { - const char *s = (const char *) value; - int len = strlen(s), seg_len = (len + 6 + 3) & ~0x3; - int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, seg_len, 0); + const unsigned int lv = get_ulong_val(value, vt); + if ((lv & 0x3ffffff) == lv) { + *out = 0x80000000; + *out |= vt << 26; + *out |= lv; + } else { + int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, 8, 0); *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt; - memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], &len, sizeof(len)); - memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6], value, len); - len += 6; - while(len < seg_len) { - *((char *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+len]) = 0x57; - len++; - } + memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], &value, 4); + *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6]) = 0x5757; *out = offset; - return; - } - - default: - warning("can't write value of type %d yet\n", vt); } - return; +} + +static void write_string_value(msft_typelib_t *typelib, int *out, const char *value) +{ + int len = strlen(value), seg_len = (len + 6 + 3) & ~0x3; + int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, seg_len, 0); + *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = VT_BSTR; + memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], &len, sizeof(len)); + memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6], value, len); + len += 6; + while(len < seg_len) { + *((char *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+len]) = 0x57; + len++; + } + *out = offset; +} + +static void write_default_value(msft_typelib_t *typelib, type_t *type, expr_t *expr, int *out) +{ + int vt; + + if (expr->type == EXPR_STRLIT || expr->type == EXPR_WSTRLIT) { + if (get_type_vt(type) != VT_BSTR) + error("string default value applied to non-string type\n"); + chat("default value '%s'\n", expr->u.sval); + write_string_value(typelib, out, expr->u.sval); + return; + } + + if (type_get_type(type) == TYPE_ENUM) { + vt = VT_I4; + } else if (is_ptr(type)) { + vt = get_type_vt(type_pointer_get_ref(type)); + if (vt == VT_USERDEFINED) + vt = VT_I4; + if (expr->cval) + warning("non-null pointer default value\n"); + } else { + vt = get_type_vt(type); + switch(vt) { + case VT_I2: + case VT_I4: + case VT_R4: + case VT_BOOL: + case VT_I1: + case VT_UI1: + case VT_UI2: + case VT_UI4: + case VT_INT: + case VT_UINT: + case VT_HRESULT: + break; + default: + warning("can't write value of type %d yet\n", vt); + return; + } + } + + write_int_value(typelib, out, vt, expr->cval); } static HRESULT set_custdata(msft_typelib_t *typelib, REFGUID guid, @@ -1280,7 +1259,10 @@ static HRESULT set_custdata(msft_typelib_t *typelib, REFGUID guid, guidentry.next_hash = -1; guidoffset = ctl2_alloc_guid(typelib, &guidentry); - write_value(typelib, &data_out, vt, value); + if(vt == VT_BSTR) + write_string_value(typelib, &data_out, value); + else + write_int_value(typelib, &data_out, vt, *(int*)value); custoffset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATAGUID, 12, 0); @@ -1293,33 +1275,6 @@ static HRESULT set_custdata(msft_typelib_t *typelib, REFGUID guid, return S_OK; } -/* It's possible to have a default value for pointer arguments too. - In this case default value has a referenced type, e.g. - 'LONG*' argument gets VT_I4, 'DOUBLE*' - VT_R8. IUnknown* and IDispatch* - are recognised too and stored as VT_UNKNOWN and VT_DISPATCH. - But IUnknown/IDispatch arguments can only have default value of 0 - (or expression that resolves to zero) while other pointers can have - any default value. */ -static int get_defaultvalue_vt(type_t *type) -{ - int vt; - if (type_get_type(type) == TYPE_ENUM) - vt = VT_I4; - else - { - vt = get_type_vt(type); - if (vt == VT_PTR && is_ptr(type)) { - vt = get_type_vt(type_pointer_get_ref(type)); - /* The only acceptable value for pointers to non-basic types - is NULL, it's stored as VT_I4 for both 32 and 64 bit typelibs. */ - if (vt == VT_USERDEFINED) - vt = VT_I4; - } - } - - return vt; -} - static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) { int offset, name_offset; @@ -1500,7 +1455,8 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) /* fill out the basic type information */ typedata[0] = typedata_size | (index << 16); - encode_var(typeinfo->typelib, type_function_get_rettype(func->type), func, &typedata[1], NULL, NULL, &decoded_size); + encode_var(typeinfo->typelib, type_function_get_rettype(func->type), func, + &typedata[1], &decoded_size); typedata[2] = funcflags; typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft; typedata[4] = (next_idx << 16) | (callconv << 8) | (invokekind << 3) | funckind; @@ -1537,26 +1493,13 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) if(defaultdata) *defaultdata = -1; - encode_var(typeinfo->typelib, arg->type, arg, paramdata, NULL, NULL, &decoded_size); + encode_var(typeinfo->typelib, arg->type, arg, paramdata, &decoded_size); if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) { switch(attr->type) { case ATTR_DEFAULTVALUE: { - int vt; - expr_t *expr = (expr_t *)attr->u.pval; - vt = get_defaultvalue_vt(arg->type); paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */ - if (expr->type == EXPR_STRLIT || expr->type == EXPR_WSTRLIT) - { - if (vt != VT_BSTR) error("string default value applied to non-string type\n"); - chat("default value '%s'\n", expr->u.sval); - write_value(typeinfo->typelib, defaultdata, vt, expr->u.sval); - } - else - { - chat("default value %d\n", expr->cval); - write_value(typeinfo->typelib, defaultdata, vt, &expr->cval); - } + write_default_value(typeinfo->typelib, arg->type, (expr_t *)attr->u.pval, defaultdata); break; } case ATTR_IN: @@ -1663,8 +1606,7 @@ static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var) int offset, id; unsigned int typedata_size; INT *typedata; - int var_datawidth; - int var_alignment; + unsigned int var_datawidth, var_alignment = 0; int var_type_size, var_kind = 0 /* VAR_PERINSTANCE */; int alignment; int varflags = 0; @@ -1766,8 +1708,8 @@ static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var) typeinfo->var_offsets[var_num] = offset; /* figure out type widths and whatnot */ - encode_var(typeinfo->typelib, var->type, var, &typedata[1], &var_datawidth, - &var_alignment, &var_type_size); + var_datawidth = type_memsize_and_alignment(var->type, &var_alignment); + encode_var(typeinfo->typelib, var->type, var, &typedata[1], &var_type_size); /* pad out starting position to data width */ typeinfo->datawidth += var_alignment - 1; @@ -1775,7 +1717,7 @@ static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var) switch(typeinfo->typekind) { case TKIND_ENUM: - write_value(typeinfo->typelib, &typedata[4], VT_I4, &var->eval->cval); + write_int_value(typeinfo->typelib, &typedata[4], VT_I4, var->eval->cval); var_kind = 2; /* VAR_CONST */ var_type_size += 16; /* sizeof(VARIANT) */ typeinfo->datawidth = var_datawidth; @@ -1791,7 +1733,6 @@ static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var) case TKIND_DISPATCH: var_kind = 3; /* VAR_DISPATCH */ typeinfo->datawidth = pointer_size; - var_alignment = 4; break; default: error("add_var_desc: unhandled type kind %d\n", typeinfo->typekind); @@ -2038,11 +1979,29 @@ static void add_dispatch(msft_typelib_t *typelib) static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinterface) { + int num_parents = 0, num_funcs = 0; + importinfo_t *importinfo = NULL; + const statement_t *stmt_func; + type_t *inherit, *ref; int idx = 0; var_t *func; var_t *var; msft_typeinfo_t *msft_typeinfo; + if (-1 < dispinterface->typelib_idx) + return; + + inherit = type_dispiface_get_inherit(dispinterface); + + if (inherit) + { + importinfo = find_importinfo(typelib, inherit->name); + + if (!importinfo && type_iface_get_inherit(inherit) && inherit->typelib_idx == -1) + add_interface_typeinfo(typelib, inherit); + } + + /* check typelib_idx again, it could have been added while resolving the parent interface */ if (-1 < dispinterface->typelib_idx) return; @@ -2051,11 +2010,31 @@ static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinte dispinterface->attrs); msft_typeinfo->typeinfo->size = pointer_size; - msft_typeinfo->typeinfo->typekind |= 0x2100; + msft_typeinfo->typeinfo->typekind |= pointer_size << 11 | pointer_size << 6; msft_typeinfo->typeinfo->flags |= 0x1000; /* TYPEFLAG_FDISPATCHABLE */ add_dispatch(typelib); - msft_typeinfo->typeinfo->cImplTypes = 1; + + if (inherit) + { + add_impl_type(msft_typeinfo, inherit, importinfo); + msft_typeinfo->typeinfo->typekind |= 0x10; + } + + /* count the number of inherited interfaces and non-local functions */ + for (ref = inherit; ref; ref = type_iface_get_inherit(ref)) + { + num_parents++; + STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(ref) ) + { + var_t *func = stmt_func->u.var; + if (!is_local(func->attrs)) num_funcs++; + } + } + msft_typeinfo->typeinfo->datatype2 = num_funcs << 16 | num_parents; + msft_typeinfo->typeinfo->cbSizeVft = num_funcs * pointer_size; + + msft_typeinfo->typeinfo->cImplTypes = 1; /* IDispatch */ /* count the no of methods, as the variable indices come after the funcs */ if (dispinterface->details.iface->disp_methods) @@ -2120,16 +2099,13 @@ static void add_interface_typeinfo(msft_typelib_t *typelib, type_t *interface) interface->typelib_idx = typelib->typelib_header.nrtypeinfos; msft_typeinfo = create_msft_typeinfo(typelib, TKIND_INTERFACE, interface->name, interface->attrs); msft_typeinfo->typeinfo->size = pointer_size; - msft_typeinfo->typeinfo->typekind |= 0x2200; + msft_typeinfo->typeinfo->typekind |= 0x0200; + msft_typeinfo->typeinfo->typekind |= pointer_size << 11; for (derived = inherit; derived; derived = type_iface_get_inherit(derived)) if (derived->name && !strcmp(derived->name, "IDispatch")) msft_typeinfo->typeinfo->flags |= 0x1000; /* TYPEFLAG_FDISPATCHABLE */ - /* can't be dual if it doesn't derive from IDispatch */ - if (!(msft_typeinfo->typeinfo->flags & 0x1000)) /* TYPEFLAG_FDISPATCHABLE */ - msft_typeinfo->typeinfo->flags &= ~0x40; /* TYPEFLAG_FDUAL */ - if(type_iface_get_inherit(interface)) add_impl_type(msft_typeinfo, type_iface_get_inherit(interface), ref_importinfo); @@ -2209,7 +2185,8 @@ static void add_union_typeinfo(msft_typelib_t *typelib, type_t *tunion) static void add_typedef_typeinfo(msft_typelib_t *typelib, type_t *tdef) { msft_typeinfo_t *msft_typeinfo = NULL; - int alignment, datatype1, datatype2, size, duplicate = 0; + int datatype1, datatype2, duplicate = 0; + unsigned int size, alignment = 0; type_t *type; if (-1 < tdef->typelib_idx) @@ -2225,8 +2202,8 @@ static void add_typedef_typeinfo(msft_typelib_t *typelib, type_t *tdef) else duplicate = 1; - encode_type(typelib, get_type_vt(type), type, - &datatype1, &size, &alignment, &datatype2); + encode_type(typelib, get_type_vt(type), type, &datatype1, &datatype2); + size = type_memsize_and_alignment(type, &alignment); if (msft_typeinfo) { @@ -2367,6 +2344,7 @@ static void add_type_typeinfo(msft_typelib_t *typelib, type_t *type) break; case TYPE_BASIC: case TYPE_POINTER: + case TYPE_ARRAY: break; default: error("add_entry: unhandled type 0x%x for %s\n", @@ -2669,7 +2647,9 @@ static void save_all_changes(msft_typelib_t *typelib) sprintf( typelib_id, "#%d", expr->cval ); add_output_to_resources( "TYPELIB", typelib_id ); output_typelib_regscript( typelib->typelib ); +#ifdef __REACTOS__ flush_output_resources( typelib_name ); +#endif } else flush_output_buffer( typelib_name ); } @@ -2687,8 +2667,6 @@ int create_msft_typelib(typelib_t *typelib) GUID midl_info_guid = {0xde77ba65,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}}; char info_string[128]; - pointer_size = (typelib_kind == SYS_WIN64) ? 8 : 4; - msft = xmalloc(sizeof(*msft)); memset(msft, 0, sizeof(*msft)); msft->typelib = typelib; @@ -2696,7 +2674,7 @@ int create_msft_typelib(typelib_t *typelib) ctl2_init_header(msft); ctl2_init_segdir(msft); - msft->typelib_header.varflags |= typelib_kind; + msft->typelib_header.varflags |= (pointer_size == 8) ? SYS_WIN64 : SYS_WIN32; /* * The following two calls return an offset or -1 if out of memory. We diff --git a/sdk/tools/widl/write_sltg.c b/sdk/tools/widl/write_sltg.c index 8f7b27afb4f..0fb5ffe642e 100644 --- a/sdk/tools/widl/write_sltg.c +++ b/sdk/tools/widl/write_sltg.c @@ -329,7 +329,7 @@ static void init_library(struct sltg_typelib *sltg) sltg->library.name = add_name(sltg, sltg->typelib->name); sltg->library.helpstring = NULL; sltg->library.helpcontext = 0; - sltg->library.syskind = typelib_kind; + sltg->library.syskind = (pointer_size == 8) ? SYS_WIN64 : SYS_WIN32; sltg->library.lcid = 0x0409; sltg->library.libflags = 0; sltg->library.version = 0; @@ -719,7 +719,7 @@ static int get_element_size(type_t *type) case VT_INT: case VT_UINT: - return typelib_kind == SYS_WIN16 ? 2 : 4; + return /* typelib_kind == SYS_WIN16 ? 2 : */ 4; case VT_UI2: case VT_I2: @@ -1824,7 +1824,6 @@ static void save_all_changes(struct sltg_typelib *typelib) sprintf(typelib_id, "#%d", expr->cval); add_output_to_resources("TYPELIB", typelib_id); output_typelib_regscript(typelib->typelib); - flush_output_resources(typelib_name); } else flush_output_buffer(typelib_name); } @@ -1836,8 +1835,6 @@ int create_sltg_typelib(typelib_t *typelib) void *library_block; int library_block_size, library_block_index; - pointer_size = (typelib_kind == SYS_WIN64) ? 8 : 4; - sltg.typelib = typelib; sltg.typeinfo_count = 0; sltg.typeinfo_size = 0;