huwcampbell.com / reactos
Reactos
fork atom

[WIDL] Sync with Wine Staging 4.0. CORE-15682

Amine Khaldi 22c8b4bf 64040f7c

+4299 -3532
+1 -1
CMakeLists.txt
··· 83 83 84 84 if(MSVC) 85 85 if(ARCH STREQUAL "i386") 86 - add_definitions(/D_X86_ /DWIN32 /D_WINDOWS) 86 + add_definitions(/D_X86_ /D__i386__ /DWIN32 /D_WINDOWS) 87 87 endif() 88 88 if(MSVC_VERSION GREATER 1699) 89 89 add_definitions(/D_ALLOW_KEYWORD_MACROS)
+1 -1
media/doc/README.WINE
··· 16 16 The following build tools are shared with Wine. 17 17 18 18 reactos/sdk/tools/unicode # Synced to WineStaging-3.3 19 - reactos/sdk/tools/widl # Synced to WineStaging-3.3 19 + reactos/sdk/tools/widl # Synced to WineStaging-4.0 20 20 reactos/sdk/tools/wpp # Synced to WineStaging-2.9 21 21 22 22 The following libraries are shared with Wine.
+1
sdk/include/host/ndrtypes.h
··· 1 + #include "../psdk/ndrtypes.h"
+116 -37
sdk/tools/widl/client.c
··· 91 91 print_client("MIDL_STUB_MESSAGE _StubMsg;\n"); 92 92 if (handle_var) 93 93 { 94 - if (explicit_fc == RPC_FC_BIND_GENERIC) 94 + if (explicit_fc == FC_BIND_GENERIC) 95 95 print_client("%s %s;\n", 96 96 get_explicit_generic_handle_type(handle_var)->name, handle_var->name ); 97 97 print_client("RPC_BINDING_HANDLE _Handle;\n"); ··· 113 113 114 114 print_client("NdrFreeBuffer(&__frame->_StubMsg);\n"); 115 115 116 - if (explicit_fc == RPC_FC_BIND_GENERIC) 116 + if (explicit_fc == FC_BIND_GENERIC) 117 117 { 118 118 fprintf(client, "\n"); 119 119 print_client("if (__frame->_Handle)\n"); ··· 144 144 if (handle_var) 145 145 { 146 146 print_client( "__frame->_Handle = 0;\n" ); 147 - if (explicit_fc == RPC_FC_BIND_GENERIC) 147 + if (explicit_fc == FC_BIND_GENERIC) 148 148 print_client("__frame->%s = %s;\n", handle_var->name, handle_var->name ); 149 149 } 150 150 if (has_ret && decl_indirect(retval->type)) ··· 180 180 181 181 switch (explicit_fc) 182 182 { 183 - case RPC_FC_BIND_PRIMITIVE: 183 + case FC_BIND_PRIMITIVE: 184 184 print_client("__frame->_Handle = %s;\n", handle_var->name); 185 185 fprintf(client, "\n"); 186 186 break; 187 - case RPC_FC_BIND_GENERIC: 187 + case FC_BIND_GENERIC: 188 188 print_client("__frame->_Handle = %s_bind(%s);\n", 189 189 get_explicit_generic_handle_type(handle_var)->name, handle_var->name); 190 190 fprintf(client, "\n"); 191 191 break; 192 - case RPC_FC_BIND_CONTEXT: 192 + case FC_BIND_CONTEXT: 193 193 { 194 194 /* if the context_handle attribute appears in the chain of types 195 195 * without pointers being followed, then the context handle must ··· 287 287 fprintf(client, "\n"); 288 288 } 289 289 290 + static void write_serialize_function(FILE *file, const type_t *type, const type_t *iface, 291 + const char *func_name, const char *ret_type) 292 + { 293 + enum stub_mode mode = get_stub_mode(); 294 + static int emited_pickling_info; 295 + 296 + if (iface && !type->typestring_offset) 297 + { 298 + /* FIXME: Those are mostly basic types. They should be implemented 299 + * using NdrMesSimpleType* functions */ 300 + if (ret_type) warning("Serialization of type %s is not supported\n", type->name); 301 + return; 302 + } 303 + 304 + if (!emited_pickling_info && iface && mode != MODE_Os) 305 + { 306 + fprintf(file, "static const MIDL_TYPE_PICKLING_INFO __MIDL_TypePicklingInfo =\n"); 307 + fprintf(file, "{\n"); 308 + fprintf(file, " 0x33205054,\n"); 309 + fprintf(file, " 0x3,\n"); 310 + fprintf(file, " 0,\n"); 311 + fprintf(file, " 0,\n"); 312 + fprintf(file, " 0\n"); 313 + fprintf(file, "};\n"); 314 + fprintf(file, "\n"); 315 + emited_pickling_info = 1; 316 + } 317 + 318 + /* FIXME: Assuming explicit handle */ 319 + 320 + fprintf(file, "%s __cdecl %s_%s(handle_t IDL_handle, %s *IDL_type)%s\n", 321 + ret_type ? ret_type : "void", type->name, func_name, type->name, iface ? "" : ";"); 322 + if (!iface) return; /* declaration only */ 323 + 324 + fprintf(file, "{\n"); 325 + fprintf(file, " %sNdrMesType%s%s(\n", ret_type ? "return " : "", func_name, 326 + mode != MODE_Os ? "2" : ""); 327 + fprintf(file, " IDL_handle,\n"); 328 + if (mode != MODE_Os) 329 + fprintf(file, " (MIDL_TYPE_PICKLING_INFO*)&__MIDL_TypePicklingInfo,\n"); 330 + fprintf(file, " &%s_StubDesc,\n", iface->name); 331 + fprintf(file, " (PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%u],\n", 332 + type->typestring_offset); 333 + fprintf(file, " IDL_type);\n"); 334 + fprintf(file, "}\n"); 335 + fprintf(file, "\n"); 336 + } 337 + 338 + void write_serialize_functions(FILE *file, const type_t *type, const type_t *iface) 339 + { 340 + if (is_attr(type->attrs, ATTR_ENCODE)) 341 + { 342 + write_serialize_function(file, type, iface, "AlignSize", "SIZE_T"); 343 + write_serialize_function(file, type, iface, "Encode", NULL); 344 + } 345 + if (is_attr(type->attrs, ATTR_DECODE)) 346 + { 347 + write_serialize_function(file, type, iface, "Decode", NULL); 348 + write_serialize_function(file, type, iface, "Free", NULL); 349 + } 350 + } 351 + 290 352 static void write_function_stubs(type_t *iface, unsigned int *proc_offset) 291 353 { 292 354 const statement_t *stmt; ··· 296 358 if (!implicit_handle) 297 359 print_client("static RPC_BINDING_HANDLE %s__MIDL_AutoBindHandle;\n\n", iface->name); 298 360 299 - STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) 361 + LIST_FOR_EACH_ENTRY( stmt, type_iface_get_stmts(iface), const statement_t, entry ) 300 362 { 301 - const var_t *func = stmt->u.var; 302 - write_function_stub( iface, func, method_count++, *proc_offset ); 303 - *proc_offset += get_size_procformatstring_func( iface, func ); 363 + switch (stmt->type) 364 + { 365 + case STMT_DECLARATION: 366 + { 367 + const var_t *func = stmt->u.var; 368 + if (stmt->u.var->stgclass != STG_NONE 369 + || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION) 370 + continue; 371 + write_function_stub( iface, func, method_count++, *proc_offset ); 372 + *proc_offset += get_size_procformatstring_func( iface, func ); 373 + break; 374 + } 375 + case STMT_TYPEDEF: 376 + { 377 + const type_list_t *type_entry; 378 + for (type_entry = stmt->u.type_list; type_entry; type_entry = type_entry->next) 379 + write_serialize_functions(client, type_entry->type, iface); 380 + break; 381 + } 382 + default: 383 + break; 384 + } 304 385 } 305 386 } 306 387 ··· 438 519 { 439 520 if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) 440 521 { 441 - int has_func = 0; 522 + int needs_stub = 0; 442 523 const statement_t *stmt2; 443 524 type_t *iface = stmt->u.type; 444 525 if (!need_stub(iface)) ··· 449 530 fprintf(client, " */\n"); 450 531 fprintf(client, "\n"); 451 532 452 - STATEMENTS_FOR_EACH_FUNC(stmt2, type_iface_get_stmts(iface)) 533 + LIST_FOR_EACH_ENTRY(stmt2, type_iface_get_stmts(iface), const statement_t, entry) 453 534 { 454 - has_func = 1; 455 - break; 535 + if (stmt2->type == STMT_DECLARATION && stmt2->u.var->stgclass == STG_NONE && 536 + type_get_type_detect_alias(stmt2->u.var->type) == TYPE_FUNCTION) 537 + { 538 + needs_stub = 1; 539 + break; 540 + } 541 + if (stmt2->type == STMT_TYPEDEF) 542 + { 543 + const type_list_t *type_entry; 544 + for (type_entry = stmt2->u.type_list; type_entry; type_entry = type_entry->next) 545 + { 546 + if (is_attr(type_entry->type->attrs, ATTR_ENCODE) 547 + || is_attr(type_entry->type->attrs, ATTR_DECODE)) 548 + { 549 + needs_stub = 1; 550 + break; 551 + } 552 + } 553 + if (needs_stub) 554 + break; 555 + } 456 556 } 457 - 458 - if (has_func) 557 + if (needs_stub) 459 558 { 460 559 write_implicithandledecl(iface); 461 560 ··· 528 627 if (!client) 529 628 return; 530 629 531 - if (do_win32 && do_win64) 532 - { 533 - fprintf(client, "#ifndef _WIN64\n\n"); 534 - pointer_size = 4; 535 - write_client_routines( stmts ); 536 - fprintf(client, "\n#else /* _WIN64 */\n\n"); 537 - pointer_size = 8; 538 - write_client_routines( stmts ); 539 - fprintf(client, "\n#endif /* _WIN64 */\n"); 540 - } 541 - else if (do_win32) 542 - { 543 - pointer_size = 4; 544 - write_client_routines( stmts ); 545 - } 546 - else if (do_win64) 547 - { 548 - pointer_size = 8; 549 - write_client_routines( stmts ); 550 - } 551 - 630 + write_client_routines( stmts ); 552 631 fclose(client); 553 632 }
+5 -3
sdk/tools/widl/expr.c
··· 50 50 case TYPE_BASIC_INT64: 51 51 case TYPE_BASIC_INT: 52 52 case TYPE_BASIC_INT3264: 53 + case TYPE_BASIC_LONG: 53 54 case TYPE_BASIC_CHAR: 54 55 case TYPE_BASIC_HYPER: 55 56 case TYPE_BASIC_BYTE: ··· 82 83 case TYPE_BASIC_INT64: 83 84 case TYPE_BASIC_INT: 84 85 case TYPE_BASIC_INT3264: 86 + case TYPE_BASIC_LONG: 85 87 return type_basic_get_sign(type) < 0; 86 88 case TYPE_BASIC_CHAR: 87 89 return TRUE; ··· 519 521 break; 520 522 case EXPR_STRLIT: 521 523 result.is_temporary = TRUE; 522 - result.type = type_new_pointer(RPC_FC_UP, type_new_int(TYPE_BASIC_CHAR, 0), NULL); 524 + result.type = type_new_pointer(FC_UP, type_new_int(TYPE_BASIC_CHAR, 0), NULL); 523 525 break; 524 526 case EXPR_WSTRLIT: 525 527 result.is_temporary = TRUE; 526 - result.type = type_new_pointer(RPC_FC_UP, type_new_int(TYPE_BASIC_WCHAR, 0), NULL); 528 + result.type = type_new_pointer(FC_UP, type_new_int(TYPE_BASIC_WCHAR, 0), NULL); 527 529 break; 528 530 case EXPR_CHARCONST: 529 531 result.is_temporary = TRUE; ··· 573 575 expr_loc->attr ? expr_loc->attr : ""); 574 576 result.is_variable = FALSE; 575 577 result.is_temporary = TRUE; 576 - result.type = type_new_pointer(RPC_FC_UP, result.type, NULL); 578 + result.type = type_new_pointer(FC_UP, result.type, NULL); 577 579 break; 578 580 case EXPR_PPTR: 579 581 result = resolve_expression(expr_loc, cont_type, e->ref);
+107 -20
sdk/tools/widl/header.c
··· 285 285 (!is_ptr(t) && (!is_array(t) || !type_array_is_decl_as_ptr(t) || t->name))); 286 286 } 287 287 288 + static void write_pointer_left(FILE *h, type_t *ref) 289 + { 290 + if (needs_space_after(ref)) 291 + fprintf(h, " "); 292 + if (!type_is_alias(ref) && is_array(ref) && !type_array_is_decl_as_ptr(ref)) 293 + fprintf(h, "("); 294 + fprintf(h, "*"); 295 + } 296 + 288 297 void write_type_left(FILE *h, type_t *t, enum name_type name_type, int declonly) 289 298 { 290 299 const char *name; ··· 341 350 else fprintf(h, "union %s", t->name ? t->name : ""); 342 351 break; 343 352 case TYPE_POINTER: 353 + { 344 354 write_type_left(h, type_pointer_get_ref(t), name_type, declonly); 345 - fprintf(h, "%s*", needs_space_after(type_pointer_get_ref(t)) ? " " : ""); 355 + write_pointer_left(h, type_pointer_get_ref(t)); 346 356 if (is_attr(t->attrs, ATTR_CONST)) fprintf(h, "const "); 347 357 break; 358 + } 348 359 case TYPE_ARRAY: 349 360 if (t->name && type_array_is_decl_as_ptr(t)) 350 361 fprintf(h, "%s", t->name); ··· 352 363 { 353 364 write_type_left(h, type_array_get_element(t), name_type, declonly); 354 365 if (type_array_is_decl_as_ptr(t)) 355 - fprintf(h, "%s*", needs_space_after(type_array_get_element(t)) ? " " : ""); 366 + write_pointer_left(h, type_array_get_element(t)); 356 367 } 357 368 break; 358 369 case TYPE_BASIC: 359 370 if (type_basic_get_type(t) != TYPE_BASIC_INT32 && 360 371 type_basic_get_type(t) != TYPE_BASIC_INT64 && 372 + type_basic_get_type(t) != TYPE_BASIC_LONG && 361 373 type_basic_get_type(t) != TYPE_BASIC_HYPER) 362 374 { 363 375 if (type_basic_get_sign(t) < 0) fprintf(h, "signed "); ··· 377 389 case TYPE_BASIC_ERROR_STATUS_T: fprintf(h, "error_status_t"); break; 378 390 case TYPE_BASIC_HANDLE: fprintf(h, "handle_t"); break; 379 391 case TYPE_BASIC_INT32: 392 + if (type_basic_get_sign(t) > 0) 393 + fprintf(h, "UINT32"); 394 + else 395 + fprintf(h, "INT32"); 396 + break; 397 + case TYPE_BASIC_LONG: 380 398 if (type_basic_get_sign(t) > 0) 381 399 fprintf(h, "ULONG"); 382 400 else ··· 419 437 void write_type_right(FILE *h, type_t *t, int is_field) 420 438 { 421 439 if (!h) return; 440 + if (type_is_alias(t)) return; 422 441 423 442 switch (type_get_type(t)) 424 443 { 425 444 case TYPE_ARRAY: 426 - if (!type_array_is_decl_as_ptr(t)) 445 + { 446 + type_t *elem = type_array_get_element(t); 447 + if (type_array_is_decl_as_ptr(t)) 448 + { 449 + if (!type_is_alias(elem) && is_array(elem) && !type_array_is_decl_as_ptr(elem)) 450 + fprintf(h, ")"); 451 + } 452 + else 427 453 { 428 454 if (is_conformant_array(t)) 429 - { 430 455 fprintf(h, "[%s]", is_field ? "1" : ""); 431 - t = type_array_get_element(t); 432 - } 433 - for ( ; 434 - type_get_type(t) == TYPE_ARRAY && !type_array_is_decl_as_ptr(t); 435 - t = type_array_get_element(t)) 456 + else 436 457 fprintf(h, "[%u]", type_array_get_dim(t)); 437 458 } 459 + write_type_right(h, elem, FALSE); 438 460 break; 461 + } 462 + case TYPE_POINTER: 463 + { 464 + type_t *ref = type_pointer_get_ref(t); 465 + if (!type_is_alias(ref) && is_array(ref) && !type_array_is_decl_as_ptr(ref)) 466 + fprintf(h, ")"); 467 + write_type_right(h, ref, FALSE); 468 + break; 469 + } 439 470 case TYPE_BITFIELD: 440 471 fprintf(h, " : %u", type_bitfield_get_bits(t)->cval); 441 472 break; ··· 450 481 case TYPE_COCLASS: 451 482 case TYPE_FUNCTION: 452 483 case TYPE_INTERFACE: 453 - case TYPE_POINTER: 454 484 break; 455 485 } 456 486 } ··· 686 716 } 687 717 } 688 718 719 + static int write_serialize_function_decl(FILE *header, const type_t *type) 720 + { 721 + write_serialize_functions(header, type, NULL); 722 + return 1; 723 + } 724 + 725 + static int serializable_exists(FILE *header, const type_t *type) 726 + { 727 + return 0; 728 + } 729 + 730 + static int for_each_serializable(const statement_list_t *stmts, FILE *header, 731 + int (*proc)(FILE*, const type_t*)) 732 + { 733 + statement_t *stmt, *iface_stmt; 734 + statement_list_t *iface_stmts; 735 + const type_list_t *type_entry; 736 + 737 + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry ) 738 + { 739 + if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) 740 + continue; 741 + 742 + iface_stmts = type_iface_get_stmts(stmt->u.type); 743 + if (iface_stmts) LIST_FOR_EACH_ENTRY( iface_stmt, iface_stmts, statement_t, entry ) 744 + { 745 + if (iface_stmt->type != STMT_TYPEDEF) continue; 746 + for (type_entry = iface_stmt->u.type_list; type_entry; type_entry = type_entry->next) 747 + { 748 + if (!is_attr(type_entry->type->attrs, ATTR_ENCODE) 749 + && !is_attr(type_entry->type->attrs, ATTR_DECODE)) 750 + continue; 751 + if (!proc(header, type_entry->type)) 752 + return 0; 753 + } 754 + } 755 + } 756 + 757 + return 1; 758 + } 759 + 689 760 static void write_user_types(FILE *header) 690 761 { 691 762 user_type_t *ut; ··· 805 876 if (!is_attr( var->attrs, ATTR_IN ) && is_attr( var->attrs, ATTR_OUT )) continue; 806 877 if (type_get_type( var->type ) == TYPE_BASIC && type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) 807 878 { 808 - *explicit_fc = RPC_FC_BIND_PRIMITIVE; 879 + *explicit_fc = FC_BIND_PRIMITIVE; 809 880 return var; 810 881 } 811 882 if (get_explicit_generic_handle_type( var )) 812 883 { 813 - *explicit_fc = RPC_FC_BIND_GENERIC; 884 + *explicit_fc = FC_BIND_GENERIC; 814 885 return var; 815 886 } 816 887 if (is_context_handle( var->type )) 817 888 { 818 - *explicit_fc = RPC_FC_BIND_CONTEXT; 889 + *explicit_fc = FC_BIND_CONTEXT; 819 890 return var; 820 891 } 821 892 } ··· 824 895 { 825 896 if (type_get_type( var->type ) == TYPE_BASIC && 826 897 type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) 827 - *implicit_fc = RPC_FC_BIND_PRIMITIVE; 898 + *implicit_fc = FC_BIND_PRIMITIVE; 828 899 else 829 - *implicit_fc = RPC_FC_BIND_GENERIC; 900 + *implicit_fc = FC_BIND_GENERIC; 830 901 return var; 831 902 } 832 903 833 - *implicit_fc = RPC_FC_AUTO_HANDLE; 904 + *implicit_fc = FC_AUTO_HANDLE; 834 905 return NULL; 835 906 } 836 907 ··· 1276 1347 if (cas) { 1277 1348 const statement_t *stmt2 = NULL; 1278 1349 STATEMENTS_FOR_EACH_FUNC(stmt2, type_iface_get_stmts(iface)) 1279 - if (!strcmp(stmt2->u.var->name, cas->name)) 1350 + if (!strcmp(get_name(stmt2->u.var), cas->name)) 1280 1351 break; 1281 1352 if (&stmt2->entry != type_iface_get_stmts(iface)) { 1282 1353 const var_t *m = stmt2->u.var; ··· 1596 1667 case STMT_TYPE: 1597 1668 if (type_get_type(stmt->u.type) == TYPE_INTERFACE) 1598 1669 { 1599 - if (is_object(stmt->u.type) || is_attr(stmt->u.type->attrs, ATTR_DISPINTERFACE)) 1600 - write_forward(header, stmt->u.type); 1670 + type_t *iface = stmt->u.type; 1671 + if (is_object(iface) || is_attr(iface->attrs, ATTR_DISPINTERFACE)) 1672 + { 1673 + write_forward(header, iface); 1674 + if (iface->details.iface->async_iface) 1675 + write_forward(header, iface->details.iface->async_iface); 1676 + } 1601 1677 } 1602 1678 else if (type_get_type(stmt->u.type) == TYPE_COCLASS) 1603 1679 write_coclass_forward(header, stmt->u.type); ··· 1632 1708 if (type_get_type(stmt->u.type) == TYPE_INTERFACE) 1633 1709 { 1634 1710 type_t *iface = stmt->u.type; 1711 + type_t *async_iface = iface->details.iface->async_iface; 1635 1712 if (is_object(iface)) is_object_interface++; 1636 1713 if (is_attr(stmt->u.type->attrs, ATTR_DISPINTERFACE) || is_object(stmt->u.type)) 1637 1714 { 1638 1715 write_com_interface_start(header, iface); 1639 1716 write_header_stmts(header, type_iface_get_stmts(iface), stmt->u.type, TRUE); 1640 1717 write_com_interface_end(header, iface); 1718 + if (async_iface) 1719 + { 1720 + write_com_interface_start(header, async_iface); 1721 + write_com_interface_end(header, async_iface); 1722 + } 1641 1723 } 1642 1724 else 1643 1725 { ··· 1717 1799 } 1718 1800 fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n\n", PACKAGE_VERSION, input_name); 1719 1801 1802 + fprintf(header, "#ifdef _WIN32\n"); 1720 1803 fprintf(header, "#ifndef __REQUIRED_RPCNDR_H_VERSION__\n"); 1721 1804 fprintf(header, "#define __REQUIRED_RPCNDR_H_VERSION__ 475\n"); 1722 1805 fprintf(header, "#endif\n\n"); ··· 1726 1809 fprintf(header, "#endif\n\n"); 1727 1810 1728 1811 fprintf(header, "#include <rpc.h>\n" ); 1729 - fprintf(header, "#include <rpcndr.h>\n\n" ); 1812 + fprintf(header, "#include <rpcndr.h>\n" ); 1813 + if (!for_each_serializable(stmts, NULL, serializable_exists)) 1814 + fprintf(header, "#include <midles.h>\n" ); 1815 + fprintf(header, "#endif\n\n"); 1730 1816 1731 1817 fprintf(header, "#ifndef COM_NO_WINDOWS_H\n"); 1732 1818 fprintf(header, "#include <windows.h>\n"); ··· 1748 1834 1749 1835 fprintf(header, "/* Begin additional prototypes for all interfaces */\n"); 1750 1836 fprintf(header, "\n"); 1837 + for_each_serializable(stmts, header, write_serialize_function_decl); 1751 1838 write_user_types(header); 1752 1839 write_generic_handle_routines(header); 1753 1840 write_context_handle_rundowns(header);
+2 -1
sdk/tools/widl/header.h
··· 48 48 extern int need_inline_stubs_file(const statement_list_t *stmts); 49 49 extern const var_t *is_callas(const attr_list_t *list); 50 50 extern void write_args(FILE *h, const var_list_t *arg, const char *name, int obj, int do_indent); 51 - extern void write_array(FILE *h, array_dims_t *v, int field); 52 51 extern const type_t* get_explicit_generic_handle_type(const var_t* var); 53 52 extern const var_t *get_func_handle_var( const type_t *iface, const var_t *func, 54 53 unsigned char *explicit_fc, unsigned char *implicit_fc ); 55 54 extern int has_out_arg_or_return(const var_t *func); 56 55 extern int is_const_decl(const var_t *var); 56 + 57 + extern void write_serialize_functions(FILE *file, const type_t *type, const type_t *iface); 57 58 58 59 static inline int is_ptr(const type_t *t) 59 60 {
+43 -3
sdk/tools/widl/parser.l
··· 76 76 static int kw_token(const char *kw); 77 77 static int attr_token(const char *kw); 78 78 79 + static void switch_to_acf(void); 80 + 79 81 static warning_list_t *disabled_warnings = NULL; 80 82 81 83 #define MAX_IMPORT_DEPTH 20 ··· 225 227 <INITIAL,ATTR>\.\.\. return ELLIPSIS; 226 228 <INITIAL,ATTR>. return yytext[0]; 227 229 <<EOF>> { 228 - if (import_stack_ptr) 229 - return aEOF; 230 - else yyterminate(); 230 + if (import_stack_ptr) 231 + return aEOF; 232 + if (acf_name) 233 + { 234 + switch_to_acf(); 235 + return aACF; 236 + } 237 + yyterminate(); 231 238 } 232 239 %% 233 240 ··· 250 257 {"TRUE", tTRUE}, 251 258 {"__cdecl", tCDECL}, 252 259 {"__fastcall", tFASTCALL}, 260 + {"__int32", tINT32}, 253 261 {"__int3264", tINT3264}, 254 262 {"__int64", tINT64}, 255 263 {"__pascal", tPASCAL}, ··· 560 568 561 569 for (ptr=0; ptr<import_stack_ptr; ptr++) 562 570 unlink(import_stack[ptr].temp_name); 571 + } 572 + 573 + static void switch_to_acf(void) 574 + { 575 + int ptr = import_stack_ptr; 576 + int ret, fd; 577 + char *name; 578 + FILE *f; 579 + 580 + assert(import_stack_ptr == 0); 581 + 582 + input_name = acf_name; 583 + acf_name = NULL; 584 + line_number = 1; 585 + 586 + name = xstrdup( "widl.XXXXXX" ); 587 + if((fd = mkstemps( name, 0 )) == -1) 588 + error("Could not generate a temp name from %s\n", name); 589 + 590 + temp_name = name; 591 + if (!(f = fdopen(fd, "wt"))) 592 + error("Could not open fd %s for writing\n", name); 593 + 594 + ret = wpp_parse(input_name, f); 595 + fclose(f); 596 + if (ret) exit(1); 597 + 598 + if((f = fopen(temp_name, "r")) == NULL) 599 + error_loc("Unable to open %s\n", temp_name); 600 + 601 + import_stack[ptr].state = YY_CURRENT_BUFFER; 602 + yy_switch_to_buffer(yy_create_buffer(f, YY_BUF_SIZE)); 563 603 } 564 604 565 605 static void warning_disable(int warning)
+2580 -2380
sdk/tools/widl/parser.tab.c
··· 111 111 #include "expr.h" 112 112 #include "typetree.h" 113 113 114 - static unsigned char pointer_default = RPC_FC_UP; 114 + static unsigned char pointer_default = FC_UP; 115 115 116 116 typedef struct list typelist_t; 117 117 struct typenode { ··· 145 145 static attr_t *make_attrv(enum attr_type type, unsigned int val); 146 146 static attr_t *make_attrp(enum attr_type type, void *val); 147 147 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr); 148 - static array_dims_t *append_array(array_dims_t *list, expr_t *expr); 148 + static type_t *append_array(type_t *chain, expr_t *expr); 149 149 static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top); 150 150 static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls); 151 151 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface); ··· 155 155 static declarator_t *make_declarator(var_t *var); 156 156 static type_t *make_safearray(type_t *type); 157 157 static typelib_t *make_library(const char *name, const attr_list_t *attrs); 158 - static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type); 158 + static type_t *append_chain_type(type_t *chain, type_t *type); 159 159 static warning_list_t *append_warning(warning_list_t *, int); 160 160 161 161 static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs); ··· 186 186 static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func); 187 187 static void check_def(const type_t *t); 188 188 189 + static void check_async_uuid(type_t *iface); 190 + 189 191 static statement_t *make_statement(enum statement_type type); 190 192 static statement_t *make_statement_type_decl(type_t *type); 191 193 static statement_t *make_statement_reference(type_t *type); ··· 207 209 208 210 static struct namespace *current_namespace = &global_namespace; 209 211 212 + #ifndef __REACTOS__ 213 + static typelib_t *current_typelib; 214 + #endif 210 215 211 - #line 212 "parser.tab.c" /* yacc.c:339 */ 216 + 217 + #line 218 "parser.tab.c" /* yacc.c:339 */ 212 218 213 219 # ifndef YY_NULL 214 220 # if defined __cplusplus && 201103L <= __cplusplus ··· 228 234 229 235 /* In a future release of Bison, this section will be replaced 230 236 by #include "parser.tab.h". */ 231 - #ifndef YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 232 - # define YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 237 + #ifndef YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 238 + # define YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 233 239 /* Debug traces. */ 234 240 #ifndef YYDEBUG 235 241 # define YYDEBUG 0 ··· 254 260 aSQSTRING = 266, 255 261 aUUID = 267, 256 262 aEOF = 268, 257 - SHL = 269, 258 - SHR = 270, 259 - MEMBERPTR = 271, 260 - EQUALITY = 272, 261 - INEQUALITY = 273, 262 - GREATEREQUAL = 274, 263 - LESSEQUAL = 275, 264 - LOGICALOR = 276, 265 - LOGICALAND = 277, 266 - ELLIPSIS = 278, 267 - tAGGREGATABLE = 279, 268 - tALLOCATE = 280, 269 - tANNOTATION = 281, 270 - tAPPOBJECT = 282, 271 - tASYNC = 283, 272 - tASYNCUUID = 284, 273 - tAUTOHANDLE = 285, 274 - tBINDABLE = 286, 275 - tBOOLEAN = 287, 276 - tBROADCAST = 288, 277 - tBYTE = 289, 278 - tBYTECOUNT = 290, 279 - tCALLAS = 291, 280 - tCALLBACK = 292, 281 - tCASE = 293, 282 - tCDECL = 294, 283 - tCHAR = 295, 284 - tCOCLASS = 296, 285 - tCODE = 297, 286 - tCOMMSTATUS = 298, 287 - tCONST = 299, 288 - tCONTEXTHANDLE = 300, 289 - tCONTEXTHANDLENOSERIALIZE = 301, 290 - tCONTEXTHANDLESERIALIZE = 302, 291 - tCONTROL = 303, 292 - tCPPQUOTE = 304, 293 - tDECODE = 305, 294 - tDEFAULT = 306, 295 - tDEFAULTBIND = 307, 296 - tDEFAULTCOLLELEM = 308, 297 - tDEFAULTVALUE = 309, 298 - tDEFAULTVTABLE = 310, 299 - tDISABLECONSISTENCYCHECK = 311, 300 - tDISPLAYBIND = 312, 301 - tDISPINTERFACE = 313, 302 - tDLLNAME = 314, 303 - tDOUBLE = 315, 304 - tDUAL = 316, 305 - tENABLEALLOCATE = 317, 306 - tENCODE = 318, 307 - tENDPOINT = 319, 308 - tENTRY = 320, 309 - tENUM = 321, 310 - tERRORSTATUST = 322, 311 - tEXPLICITHANDLE = 323, 312 - tEXTERN = 324, 313 - tFALSE = 325, 314 - tFASTCALL = 326, 315 - tFAULTSTATUS = 327, 316 - tFLOAT = 328, 317 - tFORCEALLOCATE = 329, 318 - tHANDLE = 330, 319 - tHANDLET = 331, 320 - tHELPCONTEXT = 332, 321 - tHELPFILE = 333, 322 - tHELPSTRING = 334, 323 - tHELPSTRINGCONTEXT = 335, 324 - tHELPSTRINGDLL = 336, 325 - tHIDDEN = 337, 326 - tHYPER = 338, 327 - tID = 339, 328 - tIDEMPOTENT = 340, 329 - tIGNORE = 341, 330 - tIIDIS = 342, 331 - tIMMEDIATEBIND = 343, 332 - tIMPLICITHANDLE = 344, 333 - tIMPORT = 345, 334 - tIMPORTLIB = 346, 335 - tIN = 347, 336 - tIN_LINE = 348, 337 - tINLINE = 349, 338 - tINPUTSYNC = 350, 339 - tINT = 351, 340 - tINT3264 = 352, 341 - tINT64 = 353, 342 - tINTERFACE = 354, 343 - tLCID = 355, 344 - tLENGTHIS = 356, 345 - tLIBRARY = 357, 346 - tLICENSED = 358, 347 - tLOCAL = 359, 348 - tLONG = 360, 349 - tMAYBE = 361, 350 - tMESSAGE = 362, 351 - tMETHODS = 363, 352 - tMODULE = 364, 353 - tNAMESPACE = 365, 354 - tNOCODE = 366, 355 - tNONBROWSABLE = 367, 356 - tNONCREATABLE = 368, 357 - tNONEXTENSIBLE = 369, 358 - tNOTIFY = 370, 359 - tNOTIFYFLAG = 371, 360 - tNULL = 372, 361 - tOBJECT = 373, 362 - tODL = 374, 363 - tOLEAUTOMATION = 375, 364 - tOPTIMIZE = 376, 365 - tOPTIONAL = 377, 366 - tOUT = 378, 367 - tPARTIALIGNORE = 379, 368 - tPASCAL = 380, 369 - tPOINTERDEFAULT = 381, 370 - tPRAGMA_WARNING = 382, 371 - tPROGID = 383, 372 - tPROPERTIES = 384, 373 - tPROPGET = 385, 374 - tPROPPUT = 386, 375 - tPROPPUTREF = 387, 376 - tPROXY = 388, 377 - tPTR = 389, 378 - tPUBLIC = 390, 379 - tRANGE = 391, 380 - tREADONLY = 392, 381 - tREF = 393, 382 - tREGISTER = 394, 383 - tREPRESENTAS = 395, 384 - tREQUESTEDIT = 396, 385 - tRESTRICTED = 397, 386 - tRETVAL = 398, 387 - tSAFEARRAY = 399, 388 - tSHORT = 400, 389 - tSIGNED = 401, 390 - tSIZEIS = 402, 391 - tSIZEOF = 403, 392 - tSMALL = 404, 393 - tSOURCE = 405, 394 - tSTATIC = 406, 395 - tSTDCALL = 407, 396 - tSTRICTCONTEXTHANDLE = 408, 397 - tSTRING = 409, 398 - tSTRUCT = 410, 399 - tSWITCH = 411, 400 - tSWITCHIS = 412, 401 - tSWITCHTYPE = 413, 402 - tTHREADING = 414, 403 - tTRANSMITAS = 415, 404 - tTRUE = 416, 405 - tTYPEDEF = 417, 406 - tUIDEFAULT = 418, 407 - tUNION = 419, 408 - tUNIQUE = 420, 409 - tUNSIGNED = 421, 410 - tUSESGETLASTERROR = 422, 411 - tUSERMARSHAL = 423, 412 - tUUID = 424, 413 - tV1ENUM = 425, 414 - tVARARG = 426, 415 - tVERSION = 427, 416 - tVIPROGID = 428, 417 - tVOID = 429, 418 - tWCHAR = 430, 419 - tWIREMARSHAL = 431, 420 - tAPARTMENT = 432, 421 - tNEUTRAL = 433, 422 - tSINGLE = 434, 423 - tFREE = 435, 424 - tBOTH = 436, 425 - CAST = 437, 426 - PPTR = 438, 427 - POS = 439, 428 - NEG = 440, 429 - ADDRESSOF = 441 263 + aACF = 269, 264 + SHL = 270, 265 + SHR = 271, 266 + MEMBERPTR = 272, 267 + EQUALITY = 273, 268 + INEQUALITY = 274, 269 + GREATEREQUAL = 275, 270 + LESSEQUAL = 276, 271 + LOGICALOR = 277, 272 + LOGICALAND = 278, 273 + ELLIPSIS = 279, 274 + tAGGREGATABLE = 280, 275 + tALLOCATE = 281, 276 + tANNOTATION = 282, 277 + tAPPOBJECT = 283, 278 + tASYNC = 284, 279 + tASYNCUUID = 285, 280 + tAUTOHANDLE = 286, 281 + tBINDABLE = 287, 282 + tBOOLEAN = 288, 283 + tBROADCAST = 289, 284 + tBYTE = 290, 285 + tBYTECOUNT = 291, 286 + tCALLAS = 292, 287 + tCALLBACK = 293, 288 + tCASE = 294, 289 + tCDECL = 295, 290 + tCHAR = 296, 291 + tCOCLASS = 297, 292 + tCODE = 298, 293 + tCOMMSTATUS = 299, 294 + tCONST = 300, 295 + tCONTEXTHANDLE = 301, 296 + tCONTEXTHANDLENOSERIALIZE = 302, 297 + tCONTEXTHANDLESERIALIZE = 303, 298 + tCONTROL = 304, 299 + tCPPQUOTE = 305, 300 + tDECODE = 306, 301 + tDEFAULT = 307, 302 + tDEFAULTBIND = 308, 303 + tDEFAULTCOLLELEM = 309, 304 + tDEFAULTVALUE = 310, 305 + tDEFAULTVTABLE = 311, 306 + tDISABLECONSISTENCYCHECK = 312, 307 + tDISPLAYBIND = 313, 308 + tDISPINTERFACE = 314, 309 + tDLLNAME = 315, 310 + tDOUBLE = 316, 311 + tDUAL = 317, 312 + tENABLEALLOCATE = 318, 313 + tENCODE = 319, 314 + tENDPOINT = 320, 315 + tENTRY = 321, 316 + tENUM = 322, 317 + tERRORSTATUST = 323, 318 + tEXPLICITHANDLE = 324, 319 + tEXTERN = 325, 320 + tFALSE = 326, 321 + tFASTCALL = 327, 322 + tFAULTSTATUS = 328, 323 + tFLOAT = 329, 324 + tFORCEALLOCATE = 330, 325 + tHANDLE = 331, 326 + tHANDLET = 332, 327 + tHELPCONTEXT = 333, 328 + tHELPFILE = 334, 329 + tHELPSTRING = 335, 330 + tHELPSTRINGCONTEXT = 336, 331 + tHELPSTRINGDLL = 337, 332 + tHIDDEN = 338, 333 + tHYPER = 339, 334 + tID = 340, 335 + tIDEMPOTENT = 341, 336 + tIGNORE = 342, 337 + tIIDIS = 343, 338 + tIMMEDIATEBIND = 344, 339 + tIMPLICITHANDLE = 345, 340 + tIMPORT = 346, 341 + tIMPORTLIB = 347, 342 + tIN = 348, 343 + tIN_LINE = 349, 344 + tINLINE = 350, 345 + tINPUTSYNC = 351, 346 + tINT = 352, 347 + tINT32 = 353, 348 + tINT3264 = 354, 349 + tINT64 = 355, 350 + tINTERFACE = 356, 351 + tLCID = 357, 352 + tLENGTHIS = 358, 353 + tLIBRARY = 359, 354 + tLICENSED = 360, 355 + tLOCAL = 361, 356 + tLONG = 362, 357 + tMAYBE = 363, 358 + tMESSAGE = 364, 359 + tMETHODS = 365, 360 + tMODULE = 366, 361 + tNAMESPACE = 367, 362 + tNOCODE = 368, 363 + tNONBROWSABLE = 369, 364 + tNONCREATABLE = 370, 365 + tNONEXTENSIBLE = 371, 366 + tNOTIFY = 372, 367 + tNOTIFYFLAG = 373, 368 + tNULL = 374, 369 + tOBJECT = 375, 370 + tODL = 376, 371 + tOLEAUTOMATION = 377, 372 + tOPTIMIZE = 378, 373 + tOPTIONAL = 379, 374 + tOUT = 380, 375 + tPARTIALIGNORE = 381, 376 + tPASCAL = 382, 377 + tPOINTERDEFAULT = 383, 378 + tPRAGMA_WARNING = 384, 379 + tPROGID = 385, 380 + tPROPERTIES = 386, 381 + tPROPGET = 387, 382 + tPROPPUT = 388, 383 + tPROPPUTREF = 389, 384 + tPROXY = 390, 385 + tPTR = 391, 386 + tPUBLIC = 392, 387 + tRANGE = 393, 388 + tREADONLY = 394, 389 + tREF = 395, 390 + tREGISTER = 396, 391 + tREPRESENTAS = 397, 392 + tREQUESTEDIT = 398, 393 + tRESTRICTED = 399, 394 + tRETVAL = 400, 395 + tSAFEARRAY = 401, 396 + tSHORT = 402, 397 + tSIGNED = 403, 398 + tSIZEIS = 404, 399 + tSIZEOF = 405, 400 + tSMALL = 406, 401 + tSOURCE = 407, 402 + tSTATIC = 408, 403 + tSTDCALL = 409, 404 + tSTRICTCONTEXTHANDLE = 410, 405 + tSTRING = 411, 406 + tSTRUCT = 412, 407 + tSWITCH = 413, 408 + tSWITCHIS = 414, 409 + tSWITCHTYPE = 415, 410 + tTHREADING = 416, 411 + tTRANSMITAS = 417, 412 + tTRUE = 418, 413 + tTYPEDEF = 419, 414 + tUIDEFAULT = 420, 415 + tUNION = 421, 416 + tUNIQUE = 422, 417 + tUNSIGNED = 423, 418 + tUSESGETLASTERROR = 424, 419 + tUSERMARSHAL = 425, 420 + tUUID = 426, 421 + tV1ENUM = 427, 422 + tVARARG = 428, 423 + tVERSION = 429, 424 + tVIPROGID = 430, 425 + tVOID = 431, 426 + tWCHAR = 432, 427 + tWIREMARSHAL = 433, 428 + tAPARTMENT = 434, 429 + tNEUTRAL = 435, 430 + tSINGLE = 436, 431 + tFREE = 437, 432 + tBOTH = 438, 433 + CAST = 439, 434 + PPTR = 440, 435 + POS = 441, 436 + NEG = 442, 437 + ADDRESSOF = 443 430 438 }; 431 439 #endif 432 440 ··· 435 443 typedef union YYSTYPE YYSTYPE; 436 444 union YYSTYPE 437 445 { 438 - #line 138 "parser.y" /* yacc.c:355 */ 446 + #line 144 "parser.y" /* yacc.c:355 */ 439 447 440 448 attr_t *attr; 441 449 attr_list_t *attr_list; 442 450 str_list_t *str_list; 443 451 expr_t *expr; 444 452 expr_list_t *expr_list; 445 - array_dims_t *array_dims; 446 453 type_t *type; 447 454 var_t *var; 448 455 var_list_t *var_list; ··· 464 471 struct _decl_spec_t *declspec; 465 472 enum storage_class stgclass; 466 473 467 - #line 468 "parser.tab.c" /* yacc.c:355 */ 474 + #line 475 "parser.tab.c" /* yacc.c:355 */ 468 475 }; 469 476 # define YYSTYPE_IS_TRIVIAL 1 470 477 # define YYSTYPE_IS_DECLARED 1 ··· 475 482 476 483 int parser_parse (void); 477 484 478 - #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ 485 + #endif /* !YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ 479 486 480 487 /* Copy the second part of user declarations. */ 481 488 482 - #line 483 "parser.tab.c" /* yacc.c:358 */ 489 + #line 490 "parser.tab.c" /* yacc.c:358 */ 483 490 484 491 #ifdef short 485 492 # undef short ··· 702 709 /* YYFINAL -- State number of the termination state. */ 703 710 #define YYFINAL 3 704 711 /* YYLAST -- Last index in YYTABLE. */ 705 - #define YYLAST 2995 712 + #define YYLAST 3047 706 713 707 714 /* YYNTOKENS -- Number of terminals. */ 708 - #define YYNTOKENS 211 715 + #define YYNTOKENS 213 709 716 /* YYNNTS -- Number of nonterminals. */ 710 - #define YYNNTS 105 717 + #define YYNNTS 113 711 718 /* YYNRULES -- Number of rules. */ 712 - #define YYNRULES 394 719 + #define YYNRULES 410 713 720 /* YYNSTATES -- Number of states. */ 714 - #define YYNSTATES 691 721 + #define YYNSTATES 718 715 722 716 723 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 717 724 by yylex, with out-of-bounds checking. */ 718 725 #define YYUNDEFTOK 2 719 - #define YYMAXUTOK 441 726 + #define YYMAXUTOK 443 720 727 721 728 #define YYTRANSLATE(YYX) \ 722 729 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) ··· 728 735 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 729 736 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 730 737 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 731 - 2, 2, 2, 195, 2, 2, 2, 194, 187, 2, 732 - 208, 209, 192, 191, 182, 190, 202, 193, 2, 2, 733 - 2, 2, 2, 2, 2, 2, 2, 2, 184, 207, 734 - 188, 210, 189, 183, 2, 2, 2, 2, 2, 2, 738 + 2, 2, 2, 197, 2, 2, 2, 196, 189, 2, 739 + 210, 211, 194, 193, 184, 192, 204, 195, 2, 2, 740 + 2, 2, 2, 2, 2, 2, 2, 2, 186, 209, 741 + 190, 212, 191, 185, 2, 2, 2, 2, 2, 2, 735 742 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 736 743 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 737 - 2, 203, 2, 204, 186, 2, 2, 2, 2, 2, 744 + 2, 205, 2, 206, 188, 2, 2, 2, 2, 2, 738 745 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 739 746 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 740 - 2, 2, 2, 205, 185, 206, 196, 2, 2, 2, 747 + 2, 2, 2, 207, 187, 208, 198, 2, 2, 2, 741 748 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 742 749 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 743 750 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ··· 768 775 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 769 776 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 770 777 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 771 - 175, 176, 177, 178, 179, 180, 181, 197, 198, 199, 772 - 200, 201 778 + 175, 176, 177, 178, 179, 180, 181, 182, 183, 199, 779 + 200, 201, 202, 203 773 780 }; 774 781 775 782 #if YYDEBUG 776 783 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 777 784 static const yytype_uint16 yyrline[] = 778 785 { 779 - 0, 321, 321, 335, 336, 336, 338, 339, 340, 343, 780 - 346, 347, 348, 351, 352, 353, 353, 355, 356, 357, 781 - 360, 361, 362, 363, 366, 367, 370, 371, 375, 376, 782 - 377, 378, 379, 380, 381, 384, 395, 396, 400, 401, 783 - 402, 403, 404, 405, 406, 407, 408, 411, 413, 421, 784 - 427, 431, 432, 434, 438, 445, 446, 449, 450, 453, 785 - 454, 458, 463, 470, 474, 475, 478, 479, 483, 486, 786 - 487, 488, 491, 492, 495, 496, 497, 498, 499, 500, 787 - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 788 - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 789 - 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 790 - 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 791 - 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 792 - 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 793 - 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 794 - 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 795 - 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 796 - 594, 595, 596, 597, 601, 602, 607, 608, 609, 610, 797 - 613, 614, 617, 621, 627, 628, 629, 632, 636, 648, 798 - 652, 657, 660, 661, 664, 665, 668, 669, 670, 671, 799 - 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 800 - 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 801 - 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 802 - 702, 703, 704, 705, 707, 709, 710, 713, 714, 717, 803 - 723, 729, 730, 733, 738, 745, 746, 749, 750, 754, 804 - 755, 758, 762, 768, 776, 780, 785, 786, 789, 790, 805 - 791, 794, 796, 799, 800, 801, 802, 803, 804, 805, 806 - 806, 807, 808, 809, 812, 813, 816, 817, 818, 819, 807 - 820, 821, 822, 823, 826, 827, 835, 841, 845, 848, 808 - 849, 853, 856, 857, 860, 869, 870, 873, 874, 877, 809 - 883, 889, 890, 893, 894, 897, 907, 916, 922, 926, 810 - 927, 930, 931, 934, 939, 946, 947, 948, 952, 956, 811 - 959, 960, 963, 964, 968, 969, 973, 974, 975, 979, 812 - 981, 983, 987, 988, 989, 990, 998, 1000, 1002, 1007, 813 - 1009, 1014, 1015, 1020, 1021, 1022, 1023, 1028, 1037, 1039, 814 - 1040, 1045, 1047, 1051, 1052, 1059, 1060, 1061, 1062, 1063, 815 - 1068, 1076, 1077, 1080, 1081, 1084, 1091, 1092, 1097, 1098, 816 - 1102, 1103, 1104, 1105, 1106, 1110, 1111, 1112, 1115, 1118, 817 - 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1130, 818 - 1137, 1139, 1145, 1146, 1147 786 + 0, 327, 327, 344, 344, 346, 347, 347, 349, 350, 787 + 351, 354, 357, 358, 359, 362, 363, 364, 364, 366, 788 + 367, 368, 371, 372, 373, 374, 377, 378, 381, 382, 789 + 386, 387, 388, 389, 390, 391, 392, 395, 406, 407, 790 + 411, 412, 413, 414, 415, 416, 417, 418, 419, 422, 791 + 424, 432, 438, 446, 447, 449, 457, 468, 469, 472, 792 + 473, 476, 477, 481, 486, 493, 497, 498, 501, 502, 793 + 506, 509, 510, 511, 514, 515, 518, 519, 520, 521, 794 + 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 795 + 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 796 + 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 797 + 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 798 + 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 799 + 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 800 + 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 801 + 592, 593, 597, 598, 599, 600, 601, 602, 603, 604, 802 + 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 803 + 615, 616, 617, 618, 619, 620, 624, 625, 630, 631, 804 + 632, 633, 636, 637, 640, 644, 650, 651, 652, 655, 805 + 659, 671, 675, 680, 683, 684, 687, 688, 691, 692, 806 + 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 807 + 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 808 + 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 809 + 723, 724, 725, 726, 727, 728, 730, 732, 733, 736, 810 + 737, 740, 746, 752, 753, 756, 761, 768, 769, 772, 811 + 773, 777, 778, 781, 785, 791, 799, 803, 808, 809, 812 + 812, 813, 814, 817, 819, 822, 823, 824, 825, 826, 813 + 827, 828, 829, 830, 831, 832, 835, 836, 839, 840, 814 + 841, 842, 843, 844, 845, 846, 847, 850, 851, 859, 815 + 865, 869, 872, 873, 877, 880, 881, 884, 893, 894, 816 + 897, 898, 901, 907, 913, 914, 917, 918, 921, 931, 817 + 941, 947, 951, 952, 955, 956, 959, 964, 971, 972, 818 + 973, 977, 981, 984, 985, 988, 989, 993, 994, 998, 819 + 999, 1000, 1004, 1006, 1008, 1012, 1013, 1014, 1015, 1023, 820 + 1025, 1027, 1032, 1034, 1039, 1040, 1045, 1046, 1047, 1048, 821 + 1053, 1062, 1064, 1065, 1070, 1072, 1076, 1077, 1084, 1085, 822 + 1086, 1087, 1088, 1093, 1101, 1102, 1105, 1106, 1109, 1116, 823 + 1117, 1122, 1123, 1127, 1128, 1129, 1130, 1131, 1135, 1136, 824 + 1137, 1140, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 825 + 1151, 1152, 1155, 1162, 1164, 1170, 1171, 1172, 1175, 1177, 826 + 1179, 1181, 1184, 1189, 1197, 1198, 1201, 1202, 1205, 1206, 827 + 1207 819 828 }; 820 829 #endif 821 830 ··· 826 835 { 827 836 "$end", "error", "$undefined", "aIDENTIFIER", "aPRAGMA", "aKNOWNTYPE", 828 837 "aNUM", "aHEXNUM", "aDOUBLE", "aSTRING", "aWSTRING", "aSQSTRING", 829 - "aUUID", "aEOF", "SHL", "SHR", "MEMBERPTR", "EQUALITY", "INEQUALITY", 830 - "GREATEREQUAL", "LESSEQUAL", "LOGICALOR", "LOGICALAND", "ELLIPSIS", 831 - "tAGGREGATABLE", "tALLOCATE", "tANNOTATION", "tAPPOBJECT", "tASYNC", 832 - "tASYNCUUID", "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN", "tBROADCAST", 833 - "tBYTE", "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE", "tCDECL", 834 - "tCHAR", "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST", "tCONTEXTHANDLE", 835 - "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE", "tCONTROL", 836 - "tCPPQUOTE", "tDECODE", "tDEFAULT", "tDEFAULTBIND", "tDEFAULTCOLLELEM", 837 - "tDEFAULTVALUE", "tDEFAULTVTABLE", "tDISABLECONSISTENCYCHECK", 838 - "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME", "tDOUBLE", "tDUAL", 839 - "tENABLEALLOCATE", "tENCODE", "tENDPOINT", "tENTRY", "tENUM", 840 - "tERRORSTATUST", "tEXPLICITHANDLE", "tEXTERN", "tFALSE", "tFASTCALL", 841 - "tFAULTSTATUS", "tFLOAT", "tFORCEALLOCATE", "tHANDLE", "tHANDLET", 842 - "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING", "tHELPSTRINGCONTEXT", 843 - "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID", "tIDEMPOTENT", "tIGNORE", 844 - "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE", "tIMPORT", "tIMPORTLIB", 845 - "tIN", "tIN_LINE", "tINLINE", "tINPUTSYNC", "tINT", "tINT3264", "tINT64", 846 - "tINTERFACE", "tLCID", "tLENGTHIS", "tLIBRARY", "tLICENSED", "tLOCAL", 847 - "tLONG", "tMAYBE", "tMESSAGE", "tMETHODS", "tMODULE", "tNAMESPACE", 848 - "tNOCODE", "tNONBROWSABLE", "tNONCREATABLE", "tNONEXTENSIBLE", "tNOTIFY", 838 + "aUUID", "aEOF", "aACF", "SHL", "SHR", "MEMBERPTR", "EQUALITY", 839 + "INEQUALITY", "GREATEREQUAL", "LESSEQUAL", "LOGICALOR", "LOGICALAND", 840 + "ELLIPSIS", "tAGGREGATABLE", "tALLOCATE", "tANNOTATION", "tAPPOBJECT", 841 + "tASYNC", "tASYNCUUID", "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN", 842 + "tBROADCAST", "tBYTE", "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE", 843 + "tCDECL", "tCHAR", "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST", 844 + "tCONTEXTHANDLE", "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE", 845 + "tCONTROL", "tCPPQUOTE", "tDECODE", "tDEFAULT", "tDEFAULTBIND", 846 + "tDEFAULTCOLLELEM", "tDEFAULTVALUE", "tDEFAULTVTABLE", 847 + "tDISABLECONSISTENCYCHECK", "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME", 848 + "tDOUBLE", "tDUAL", "tENABLEALLOCATE", "tENCODE", "tENDPOINT", "tENTRY", 849 + "tENUM", "tERRORSTATUST", "tEXPLICITHANDLE", "tEXTERN", "tFALSE", 850 + "tFASTCALL", "tFAULTSTATUS", "tFLOAT", "tFORCEALLOCATE", "tHANDLE", 851 + "tHANDLET", "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING", 852 + "tHELPSTRINGCONTEXT", "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID", 853 + "tIDEMPOTENT", "tIGNORE", "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE", 854 + "tIMPORT", "tIMPORTLIB", "tIN", "tIN_LINE", "tINLINE", "tINPUTSYNC", 855 + "tINT", "tINT32", "tINT3264", "tINT64", "tINTERFACE", "tLCID", 856 + "tLENGTHIS", "tLIBRARY", "tLICENSED", "tLOCAL", "tLONG", "tMAYBE", 857 + "tMESSAGE", "tMETHODS", "tMODULE", "tNAMESPACE", "tNOCODE", 858 + "tNONBROWSABLE", "tNONCREATABLE", "tNONEXTENSIBLE", "tNOTIFY", 849 859 "tNOTIFYFLAG", "tNULL", "tOBJECT", "tODL", "tOLEAUTOMATION", "tOPTIMIZE", 850 860 "tOPTIONAL", "tOUT", "tPARTIALIGNORE", "tPASCAL", "tPOINTERDEFAULT", 851 861 "tPRAGMA_WARNING", "tPROGID", "tPROPERTIES", "tPROPGET", "tPROPPUT", ··· 861 871 "','", "'?'", "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "'-'", "'+'", 862 872 "'*'", "'/'", "'%'", "'!'", "'~'", "CAST", "PPTR", "POS", "NEG", 863 873 "ADDRESSOF", "'.'", "'['", "']'", "'{'", "'}'", "';'", "'('", "')'", 864 - "'='", "$accept", "input", "gbl_statements", "$@1", "imp_statements", 865 - "$@2", "int_statements", "semicolon_opt", "statement", "pragma_warning", 866 - "warnings", "typedecl", "cppquote", "import_start", "import", 867 - "importlib", "libraryhdr", "library_start", "librarydef", "m_args", 868 - "arg_list", "args", "arg", "array", "m_attributes", "attributes", 869 - "attrib_list", "str_list", "attribute", "uuid_string", "callconv", 870 - "cases", "case", "enums", "enum_list", "enum", "enumdef", "m_exprs", 871 - "m_expr", "expr", "expr_list_int_const", "expr_int_const", "expr_const", 872 - "fields", "field", "ne_union_field", "ne_union_fields", "union_field", 873 - "s_field", "funcdef", "declaration", "m_ident", "t_ident", "ident", 874 - "base_type", "m_int", "int_std", "coclass", "coclasshdr", "coclassdef", 875 - "namespacedef", "coclass_ints", "coclass_int", "dispinterface", 876 - "dispinterfacehdr", "dispint_props", "dispint_meths", "dispinterfacedef", 877 - "inherit", "interface", "interfacehdr", "interfacedef", "interfacedec", 878 - "module", "modulehdr", "moduledef", "storage_cls_spec", 879 - "function_specifier", "type_qualifier", "m_type_qual_list", "decl_spec", 880 - "m_decl_spec_no_type", "decl_spec_no_type", "declarator", 881 - "direct_declarator", "abstract_declarator", 882 - "abstract_declarator_no_direct", "m_abstract_declarator", 883 - "abstract_direct_declarator", "any_declarator", 874 + "'='", "$accept", "input", "m_acf", "gbl_statements", "$@1", 875 + "imp_statements", "$@2", "int_statements", "semicolon_opt", "statement", 876 + "pragma_warning", "warnings", "typedecl", "cppquote", "import_start", 877 + "import", "importlib", "libraryhdr", "library_start", "librarydef", 878 + "m_args", "arg_list", "args", "arg", "array", "m_attributes", 879 + "attributes", "attrib_list", "str_list", "attribute", "uuid_string", 880 + "callconv", "cases", "case", "enums", "enum_list", "enum", "enumdef", 881 + "m_exprs", "m_expr", "expr", "expr_list_int_const", "expr_int_const", 882 + "expr_const", "fields", "field", "ne_union_field", "ne_union_fields", 883 + "union_field", "s_field", "funcdef", "declaration", "m_ident", "t_ident", 884 + "ident", "base_type", "m_int", "int_std", "coclass", "coclasshdr", 885 + "coclassdef", "namespacedef", "coclass_ints", "coclass_int", 886 + "dispinterface", "dispinterfacehdr", "dispint_props", "dispint_meths", 887 + "dispinterfacedef", "inherit", "interface", "interfacehdr", 888 + "interfacedef", "interfacedec", "module", "modulehdr", "moduledef", 889 + "storage_cls_spec", "function_specifier", "type_qualifier", 890 + "m_type_qual_list", "decl_spec", "m_decl_spec_no_type", 891 + "decl_spec_no_type", "declarator", "direct_declarator", 892 + "abstract_declarator", "abstract_declarator_no_direct", 893 + "m_abstract_declarator", "abstract_direct_declarator", "any_declarator", 884 894 "any_declarator_no_direct", "m_any_declarator", "any_direct_declarator", 885 895 "declarator_list", "m_bitfield", "struct_declarator", 886 896 "struct_declarator_list", "init_declarator", "threading_type", 887 - "pointer_type", "structdef", "type", "typedef", "uniondef", "version", YY_NULL 897 + "pointer_type", "structdef", "type", "typedef", "uniondef", "version", 898 + "acf_statements", "acf_int_statements", "acf_int_statement", 899 + "acf_interface", "acf_attributes", "acf_attribute_list", "acf_attribute", YY_NULL 888 900 }; 889 901 #endif 890 902 ··· 911 923 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 912 924 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 913 925 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 914 - 435, 436, 44, 63, 58, 124, 94, 38, 60, 62, 915 - 45, 43, 42, 47, 37, 33, 126, 437, 438, 439, 916 - 440, 441, 46, 91, 93, 123, 125, 59, 40, 41, 917 - 61 926 + 435, 436, 437, 438, 44, 63, 58, 124, 94, 38, 927 + 60, 62, 45, 43, 42, 47, 37, 33, 126, 439, 928 + 440, 441, 442, 443, 46, 91, 93, 123, 125, 59, 929 + 40, 41, 61 918 930 }; 919 931 # endif 920 932 921 - #define YYPACT_NINF -521 933 + #define YYPACT_NINF -560 922 934 923 935 #define yypact_value_is_default(Yystate) \ 924 - (!!((Yystate) == (-521))) 936 + (!!((Yystate) == (-560))) 925 937 926 - #define YYTABLE_NINF -260 938 + #define YYTABLE_NINF -405 927 939 928 940 #define yytable_value_is_error(Yytable_value) \ 929 941 0 ··· 932 944 STATE-NUM. */ 933 945 static const yytype_int16 yypact[] = 934 946 { 935 - -521, 89, 1646, -521, -521, -521, -521, -521, -521, 156, 936 - -521, -136, 172, -521, 181, -521, -521, -521, -521, -6, 937 - 87, -521, -521, -521, -521, 218, -6, 105, -99, -521, 938 - -75, -6, 384, -521, -521, 223, 255, 384, -521, -521, 939 - 2819, -521, -521, -39, -521, -521, -521, -521, -521, 25, 940 - 2519, -19, -15, -521, -521, -11, 6, -521, 24, 3, 941 - 27, 15, 29, 21, -521, -521, 66, -521, 44, 44, 942 - 44, 162, 2667, 79, 44, 106, 109, -521, -521, 208, 943 - -521, -521, 94, -521, 74, -521, -521, 119, -521, -521, 944 - -521, -521, 279, 2667, -521, -521, 97, 107, -127, -120, 945 - -521, -521, 122, -521, -521, 125, -521, -521, -521, 126, 946 - 131, -521, -521, -521, -521, -521, -521, -521, -521, -521, 947 - -521, 155, -521, -521, -521, 160, -521, -521, -521, 161, 948 - 173, -521, -521, -521, -521, 179, 180, 183, 184, 192, 949 - -521, 193, -521, -521, 195, -521, 196, -521, -521, 197, 950 - 205, -521, -521, -521, -521, -521, -521, -521, -521, -521, 951 - -521, -521, -521, -521, 211, -521, -521, -521, 212, 213, 952 - -521, -521, -521, -521, -521, -521, 214, -521, -521, 215, 953 - -521, -521, -521, 217, -521, -521, -521, 222, 246, 247, 954 - 251, -521, -521, -521, 252, 260, -521, -521, 261, 263, 955 - 264, -121, -521, -521, -521, 1528, 791, 177, 319, 322, 956 - 337, 343, 347, 207, 182, -521, -521, -521, -521, 162, 957 - 209, 268, -521, -521, -521, -521, -521, -55, -521, -521, 958 - -521, 350, 271, -521, -521, -521, -521, -521, -521, -521, 959 - -521, -521, -521, -521, -521, 162, 162, -521, 267, -96, 960 - -521, -521, -521, 44, -521, -521, -521, 269, 355, -521, 961 - 289, 270, -521, 276, -521, 477, 61, 355, 646, 646, 962 - 478, 479, 646, 646, 482, 491, 646, 493, 646, 646, 963 - 2080, 646, 646, 494, -78, 497, 646, 2667, 646, 646, 964 - 2667, 194, 2667, 2667, 61, 75, 501, 2667, 2819, 308, 965 - -521, 309, -521, -521, -521, 311, -521, 314, -521, -521, 966 - -521, 15, 2593, -521, 326, -521, -521, -521, -521, 326, 967 - -102, -521, -521, -37, -521, 332, -66, 320, 329, -521, 968 - -521, 1130, 72, 327, -521, 646, 266, 2080, -521, -521, 969 - -521, 333, 353, -521, 328, 534, -521, -30, 177, -21, 970 - 335, -521, -521, 336, 341, -521, -521, -521, -521, -521, 971 - -521, -521, -521, -521, 339, -521, 646, 646, 646, 646, 972 - 646, 646, 575, 2328, -143, -521, 2328, 342, 344, -521, 973 - -123, 346, 348, 349, 351, 352, 354, 357, 1334, 358, 974 - 2593, 159, 359, -118, -521, 2328, 362, 363, 364, 367, 975 - 365, -114, 2001, 368, -521, -521, -521, -521, -521, 370, 976 - 378, 379, 380, 374, -521, 381, 382, 383, -521, 2819, 977 - 543, -521, -521, -521, 162, 15, -23, -521, 1027, -521, 978 - 375, 2593, 387, 1410, 389, 474, 1233, 15, -521, 2593, 979 - -521, -521, -521, -521, 594, -521, 2242, 390, 414, -521, 980 - -521, -521, 355, 646, -521, 18, -521, 2593, -521, 397, 981 - -521, 391, -521, 401, -521, -521, -521, 2593, 12, 12, 982 - 12, 12, 12, 12, 2111, 338, 646, 646, 607, 646, 983 - 646, 646, 646, 646, 646, 646, 646, 646, 646, 646, 984 - 646, 646, 646, 646, 646, 646, 608, 646, 646, -521, 985 - -521, -521, 604, -521, -521, -521, -521, -521, -521, -521, 986 - -521, -521, -521, 159, -521, 1775, -521, 159, -521, -521, 987 - -521, -93, -521, 646, -521, -521, -521, -521, 646, -521, 988 - -521, -521, -521, -521, -521, -521, -521, 610, -521, -521, 989 - -521, -521, 405, -521, -521, 435, -521, -521, -521, -521, 990 - 162, 169, -521, -521, 2593, 413, -521, -521, -521, 15, 991 - -521, -521, -521, -521, 2006, -521, -521, -521, -521, 159, 992 - 419, 355, -521, -521, 338, -521, -521, 1903, -521, 338, 993 - -521, 420, -58, 204, 204, -521, 718, 718, 305, 305, 994 - 2198, 2347, 2307, 103, 506, 2354, 305, 305, 115, 115, 995 - 12, 12, 12, -521, 2270, -521, -521, -521, 340, -521, 996 - 421, 159, 423, -521, 2080, -521, -521, 425, -521, 15, 997 - 909, 162, -521, -521, 1336, -521, -521, -521, 444, -521, 998 - -115, -521, 431, -521, 429, 498, -521, 430, 159, 434, 999 - -521, 646, 2080, -521, 646, -521, -521, 340, -521, -521, 1000 - -521, 437, -521, -521, -521, -521, 15, 646, -521, 159, 1001 - -521, -521, -521, -521, 340, -521, -521, -521, 12, 438, 1002 - 2328, -521, -521, -521, -521, -521, -13, -521, -521, 646, 1003 - 475, -521, -521, 476, -52, -52, -521, -521, 454, -521, 1004 - -521 947 + -560, 94, 1606, -560, -560, -560, -57, -560, -560, -560, 948 + 147, -560, -89, 165, -560, 169, -560, -560, -560, -560, 949 + 35, 149, -560, -560, -560, -560, -560, 172, 35, 164, 950 + -34, -560, -29, 35, 333, -560, -560, 192, 197, 333, 951 + -560, -560, 2869, -560, -560, -560, -27, -560, -560, -560, 952 + -560, -560, 21, 2567, -13, -10, -560, -560, 9, -36, 953 + -560, 2, 12, 38, 23, 46, 41, -560, -560, 57, 954 + -560, 128, 128, 128, 175, 2716, 76, 128, 81, 88, 955 + 61, -560, -57, 219, -560, -560, 315, -560, -560, 15, 956 + -560, 121, -560, -560, 123, -560, -560, -560, -560, 331, 957 + 2716, -560, -560, 58, 129, -94, -112, -560, -560, 130, 958 + -560, -560, 131, -560, -560, -560, 132, 134, -560, -560, 959 + -560, -560, -560, -560, -560, -560, -560, -560, 138, -560, 960 + -560, -560, 140, -560, -560, -560, 141, 146, -560, -560, 961 + -560, -560, 150, 151, 153, 157, 158, -560, 160, -560, 962 + -560, 161, -560, 163, -560, -560, 166, 167, -560, -560, 963 + -560, -560, -560, -560, -560, -560, -560, -560, -560, -560, 964 + -560, 168, -560, -560, -560, 170, 171, -560, -560, -560, 965 + -560, -560, -560, 174, -560, -560, 185, -560, -560, -560, 966 + 187, -560, -560, -560, 188, 189, 190, 191, -560, -560, 967 + -560, 195, 196, -560, -560, 206, 209, 211, -132, -560, 968 + -560, -560, 1736, 851, 133, 267, 270, 273, 283, 286, 969 + 220, 148, -560, -560, -560, -560, 175, 173, 216, -560, 970 + -560, -560, -560, -560, -42, -560, -560, -560, 290, 222, 971 + -560, -560, -560, -560, -560, -560, -560, -560, -560, -560, 972 + -560, -560, 175, 175, -560, 127, -101, -560, -560, -560, 973 + 128, -560, -560, -560, -560, -560, -560, -119, -560, -560, 974 + 374, 215, 291, -560, 249, 225, -560, 227, -560, 429, 975 + 84, 291, 710, 710, 430, 432, 710, 710, 435, 458, 976 + 710, 461, 710, 710, 2097, 710, 710, 463, -68, 464, 977 + 710, 2716, 710, 710, 2716, -38, 2716, 2716, 84, 324, 978 + 466, 2716, 2869, 271, -560, 268, -560, -560, -560, 272, 979 + -560, 278, -560, -560, -560, 23, 2612, -560, 279, -560, 980 + -560, -560, -560, 279, -91, -560, -560, -122, -560, 293, 981 + -65, 280, 284, -560, -560, 1193, 52, 266, -560, 710, 982 + 542, 2097, -560, -560, 61, -560, 285, -560, 282, 303, 983 + -560, 281, 488, -560, -49, 133, -39, 294, -560, -560, 984 + 295, 296, -560, -560, -560, -560, -560, -560, -560, -560, 985 + -560, 305, -560, 710, 710, 710, 710, 710, 710, 596, 986 + 2299, -135, -560, 2299, 306, 307, -560, -111, 308, 309, 987 + 314, 316, 317, 323, 326, 371, 327, 2612, 77, 328, 988 + -106, -560, 2299, 329, 330, 332, 311, 335, -100, 1397, 989 + 343, -560, -560, -560, -560, -560, 344, 346, 359, 360, 990 + 292, -560, 361, 362, 367, -560, 2869, 492, -560, -560, 991 + -560, 175, 23, -11, -560, 1089, -560, 340, 2612, 370, 992 + 1476, 334, 413, 1297, 23, -560, 2612, -560, -560, -560, 993 + -560, 611, -560, 2190, 377, 402, -560, -560, -560, 380, 994 + -560, 291, 710, -560, 18, -560, 2612, -560, 378, -560, 995 + 384, -560, 389, -560, -560, -560, 2612, 36, 36, 36, 996 + 36, 36, 36, 2102, 496, 710, 710, 597, 710, 710, 997 + 710, 710, 710, 710, 710, 710, 710, 710, 710, 710, 998 + 710, 710, 710, 710, 710, 605, 710, 710, -560, -560, 999 + -560, 600, -560, -560, -560, -560, -560, -560, -560, -560, 1000 + -560, -560, 77, -560, 1833, -560, 77, -560, -560, -560, 1001 + -87, -560, 710, -560, -560, -560, -560, 710, -560, -560, 1002 + -560, -560, -560, -560, -560, -560, 604, -560, -560, -560, 1003 + -560, 400, -560, -560, 428, -560, -560, -560, -560, 175, 1004 + 116, -560, -560, 2612, 407, -560, -560, -560, 23, -560, 1005 + -560, -560, -560, 2009, 419, 417, 380, -560, -560, -560, 1006 + -560, 77, 418, 291, -560, -560, 496, -560, -560, 1921, 1007 + -560, 496, -560, 415, -74, 318, 318, -560, 575, 575, 1008 + 482, 482, 2318, 2337, 2260, 2372, 2394, 218, 482, 482, 1009 + 54, 54, 36, 36, 36, -560, 2212, -560, -560, -560, 1010 + 74, -560, 421, 77, 422, -560, 2097, -560, -560, 424, 1011 + -560, 23, 970, 175, -560, -560, 1401, -560, -560, -560, 1012 + 623, -560, -560, 444, -560, -103, -560, 431, -560, 425, 1013 + 375, -560, 434, 77, 437, -560, 710, 2097, -560, 710, 1014 + -560, -560, 74, -560, -560, -560, 440, -560, -560, -560, 1015 + -560, 23, 433, 710, -560, 77, -560, -560, -560, -560, 1016 + 74, -560, -560, -560, 36, 441, 2299, -560, -560, -560, 1017 + -560, -560, -560, -1, -560, -560, 710, 453, -560, -560, 1018 + 468, -58, -58, -560, -560, 447, -560, -560 1005 1019 }; 1006 1020 1007 1021 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. ··· 1009 1023 means the default is an error. */ 1010 1024 static const yytype_uint16 yydefact[] = 1011 1025 { 1012 - 3, 0, 2, 1, 33, 380, 271, 263, 282, 0, 1013 - 319, 0, 0, 270, 258, 272, 315, 269, 273, 274, 1014 - 0, 318, 276, 283, 281, 0, 274, 0, 0, 317, 1015 - 0, 274, 0, 278, 316, 258, 258, 268, 379, 264, 1016 - 74, 12, 34, 0, 28, 13, 31, 13, 11, 0, 1017 - 67, 382, 0, 381, 265, 0, 0, 9, 0, 0, 1018 - 0, 26, 0, 301, 7, 6, 0, 10, 324, 324, 1019 - 324, 0, 0, 384, 324, 0, 386, 284, 285, 0, 1020 - 292, 293, 383, 260, 0, 275, 280, 0, 303, 304, 1021 - 279, 288, 0, 0, 277, 266, 385, 0, 387, 0, 1022 - 267, 75, 0, 77, 78, 0, 79, 80, 81, 0, 1023 - 0, 84, 85, 86, 87, 88, 89, 90, 91, 92, 1024 - 93, 0, 95, 96, 97, 0, 99, 100, 101, 0, 1025 - 0, 104, 105, 106, 107, 0, 0, 0, 0, 0, 1026 - 113, 0, 115, 116, 0, 118, 0, 120, 121, 124, 1027 - 0, 125, 126, 127, 128, 129, 130, 131, 132, 133, 1028 - 134, 135, 136, 137, 0, 139, 140, 141, 0, 0, 1029 - 144, 145, 146, 147, 377, 148, 0, 150, 375, 0, 1030 - 152, 153, 154, 0, 156, 157, 158, 0, 0, 0, 1031 - 0, 163, 376, 164, 0, 0, 168, 169, 0, 0, 1032 - 0, 0, 69, 173, 29, 66, 66, 66, 258, 0, 1033 - 0, 258, 258, 0, 382, 286, 294, 305, 313, 0, 1034 - 384, 386, 30, 8, 289, 4, 310, 0, 27, 308, 1035 - 309, 0, 0, 24, 328, 325, 327, 326, 261, 262, 1036 - 176, 177, 178, 179, 320, 0, 0, 332, 368, 331, 1037 - 255, 382, 384, 324, 386, 322, 32, 0, 184, 48, 1038 - 0, 0, 241, 0, 247, 0, 0, 0, 0, 0, 1039 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1040 - 0, 0, 194, 0, 0, 0, 0, 0, 194, 0, 1041 - 0, 0, 0, 0, 0, 0, 0, 0, 74, 68, 1042 - 49, 0, 21, 22, 23, 0, 19, 0, 17, 14, 1043 - 20, 26, 0, 67, 383, 51, 52, 311, 312, 385, 1044 - 387, 53, 254, 66, 3, 0, 66, 0, 0, 302, 1045 - 24, 66, 0, 0, 330, 0, 0, 55, 334, 323, 1046 - 47, 0, 186, 187, 190, 0, 388, 66, 66, 66, 1047 - 0, 175, 174, 0, 0, 205, 196, 197, 198, 202, 1048 - 203, 204, 199, 200, 0, 201, 0, 0, 0, 0, 1049 - 0, 0, 0, 239, 0, 237, 240, 0, 0, 72, 1026 + 5, 0, 3, 1, 35, 383, 398, 273, 265, 284, 1027 + 0, 322, 0, 0, 272, 260, 274, 318, 271, 275, 1028 + 276, 0, 321, 278, 285, 286, 283, 0, 276, 0, 1029 + 0, 320, 0, 276, 0, 280, 319, 260, 260, 270, 1030 + 382, 266, 76, 2, 14, 36, 0, 30, 15, 33, 1031 + 15, 13, 0, 69, 385, 0, 384, 267, 0, 0, 1032 + 11, 0, 0, 0, 28, 0, 304, 9, 8, 0, 1033 + 12, 327, 327, 327, 0, 0, 387, 327, 0, 389, 1034 + 0, 4, 398, 0, 287, 288, 0, 295, 296, 386, 1035 + 262, 0, 277, 282, 0, 306, 307, 281, 291, 0, 1036 + 0, 279, 268, 388, 0, 390, 0, 269, 77, 0, 1037 + 79, 80, 0, 81, 82, 83, 0, 0, 86, 87, 1038 + 88, 89, 90, 91, 92, 93, 94, 95, 0, 97, 1039 + 98, 99, 0, 101, 102, 103, 0, 0, 106, 107, 1040 + 108, 109, 0, 0, 0, 0, 0, 115, 0, 117, 1041 + 118, 0, 120, 0, 122, 123, 126, 0, 127, 128, 1042 + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 1043 + 139, 0, 141, 142, 143, 0, 0, 146, 147, 148, 1044 + 149, 380, 150, 0, 152, 378, 0, 154, 155, 156, 1045 + 0, 158, 159, 160, 0, 0, 0, 0, 165, 379, 1046 + 166, 0, 0, 170, 171, 0, 0, 0, 0, 71, 1047 + 175, 31, 68, 68, 68, 260, 0, 0, 260, 260, 1048 + 0, 385, 289, 297, 308, 316, 0, 387, 389, 32, 1049 + 10, 292, 6, 313, 0, 29, 311, 312, 0, 0, 1050 + 26, 331, 328, 330, 329, 263, 264, 178, 179, 180, 1051 + 181, 323, 0, 0, 335, 371, 334, 257, 385, 387, 1052 + 327, 389, 325, 34, 409, 408, 410, 0, 406, 399, 1053 + 0, 0, 186, 50, 0, 0, 243, 0, 249, 0, 1050 1054 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1051 - 0, 353, 0, 0, 192, 195, 0, 0, 0, 0, 1052 - 0, 0, 0, 0, 370, 371, 372, 373, 374, 0, 1053 - 0, 0, 0, 392, 394, 0, 0, 0, 70, 74, 1054 - 0, 18, 15, 54, 0, 26, 0, 290, 66, 295, 1055 - 0, 0, 0, 0, 0, 0, 66, 26, 25, 67, 1056 - 321, 329, 333, 369, 0, 65, 0, 0, 59, 56, 1057 - 57, 191, 185, 0, 36, 0, 378, 0, 242, 0, 1058 - 390, 67, 248, 0, 76, 167, 82, 0, 229, 228, 1059 - 227, 230, 225, 226, 0, 341, 0, 0, 0, 0, 1055 + 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, 1056 + 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, 1057 + 0, 0, 76, 70, 51, 0, 23, 24, 25, 0, 1058 + 21, 0, 19, 16, 22, 28, 0, 69, 386, 53, 1059 + 54, 314, 315, 388, 390, 55, 256, 68, 5, 0, 1060 + 68, 0, 0, 305, 26, 68, 0, 0, 333, 0, 1061 + 0, 57, 337, 326, 0, 405, 0, 49, 0, 188, 1062 + 189, 192, 0, 391, 68, 68, 68, 0, 177, 176, 1063 + 0, 0, 207, 198, 199, 200, 204, 205, 206, 201, 1064 + 202, 0, 203, 0, 0, 0, 0, 0, 0, 0, 1065 + 241, 0, 239, 242, 0, 0, 74, 0, 0, 0, 1066 + 0, 0, 0, 0, 0, 0, 0, 0, 356, 0, 1067 + 0, 194, 197, 0, 0, 0, 0, 0, 0, 0, 1068 + 0, 373, 374, 375, 376, 377, 0, 0, 0, 0, 1069 + 395, 397, 0, 0, 0, 72, 76, 0, 20, 17, 1070 + 56, 0, 28, 0, 293, 68, 298, 0, 0, 0, 1071 + 0, 0, 0, 68, 28, 27, 69, 324, 332, 336, 1072 + 372, 0, 67, 0, 0, 61, 58, 59, 407, 400, 1073 + 193, 187, 0, 38, 0, 381, 0, 244, 0, 393, 1074 + 69, 250, 0, 78, 169, 84, 0, 231, 230, 229, 1075 + 232, 227, 228, 0, 344, 0, 0, 0, 0, 0, 1060 1076 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1061 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 1062 - 94, 98, 0, 102, 103, 108, 109, 110, 111, 112, 1063 - 114, 117, 119, 353, 320, 55, 358, 353, 355, 354, 1064 - 62, 350, 123, 194, 122, 138, 142, 143, 0, 151, 1065 - 155, 159, 160, 162, 161, 165, 166, 0, 170, 171, 1066 - 172, 71, 0, 13, 361, 389, 287, 291, 5, 297, 1067 - 0, 384, 296, 299, 0, 0, 253, 300, 24, 26, 1068 - 314, 64, 63, 335, 0, 188, 189, 37, 35, 0, 1069 - 386, 256, 246, 245, 341, 236, 320, 55, 345, 341, 1070 - 342, 0, 338, 218, 219, 231, 212, 213, 216, 217, 1071 - 207, 208, 0, 209, 210, 211, 215, 214, 221, 220, 1072 - 223, 224, 222, 232, 0, 238, 73, 61, 353, 320, 1073 - 0, 353, 0, 349, 55, 357, 193, 0, 393, 26, 1074 - 66, 0, 251, 298, 66, 306, 60, 58, 363, 366, 1075 - 0, 244, 0, 257, 0, 341, 320, 0, 353, 0, 1076 - 337, 0, 55, 344, 0, 235, 348, 353, 359, 352, 1077 - 356, 0, 149, 50, 16, 362, 26, 0, 365, 0, 1078 - 243, 180, 234, 336, 353, 346, 340, 343, 233, 0, 1079 - 206, 351, 360, 307, 364, 367, 0, 339, 347, 0, 1080 - 0, 391, 181, 0, 66, 66, 250, 183, 0, 182, 1081 - 249 1077 + 0, 0, 0, 0, 0, 0, 0, 0, 85, 96, 1078 + 100, 0, 104, 105, 110, 111, 112, 113, 114, 116, 1079 + 119, 121, 356, 323, 57, 361, 356, 358, 357, 64, 1080 + 353, 125, 196, 124, 140, 144, 145, 0, 153, 157, 1081 + 161, 162, 164, 163, 167, 168, 0, 172, 173, 174, 1082 + 73, 0, 15, 364, 392, 290, 294, 7, 300, 0, 1083 + 387, 299, 302, 0, 0, 255, 303, 26, 28, 317, 1084 + 66, 65, 338, 0, 404, 0, 400, 190, 191, 39, 1085 + 37, 0, 389, 258, 248, 247, 344, 238, 323, 57, 1086 + 348, 344, 345, 0, 341, 220, 221, 233, 214, 215, 1087 + 218, 219, 209, 210, 0, 211, 212, 213, 217, 216, 1088 + 223, 222, 225, 226, 224, 234, 0, 240, 75, 63, 1089 + 356, 323, 0, 356, 0, 352, 57, 360, 195, 0, 1090 + 396, 28, 68, 0, 253, 301, 68, 309, 62, 60, 1091 + 0, 403, 401, 366, 369, 0, 246, 0, 259, 0, 1092 + 344, 323, 0, 356, 0, 340, 0, 57, 347, 0, 1093 + 237, 351, 356, 362, 355, 359, 0, 151, 52, 18, 1094 + 365, 28, 0, 0, 368, 0, 245, 182, 236, 339, 1095 + 356, 349, 343, 346, 235, 0, 208, 354, 363, 310, 1096 + 402, 367, 370, 0, 342, 350, 0, 0, 394, 183, 1097 + 0, 68, 68, 252, 185, 0, 184, 251 1082 1098 }; 1083 1099 1084 1100 /* YYPGOTO[NTERM-NUM]. */ 1085 1101 static const yytype_int16 yypgoto[] = 1086 1102 { 1087 - -521, -521, 360, -521, -42, -521, -304, -291, 0, -521, 1088 - -521, -521, -521, -521, 227, -521, -521, -521, 10, -472, 1089 - -521, -521, -266, -218, -191, -2, -521, -521, -275, 369, 1090 - -65, -521, -521, -521, -521, 216, 13, 377, 143, -242, 1091 - -521, -228, -264, -521, -521, -521, -521, -18, -177, -521, 1092 - 237, -521, -3, -67, -521, 110, 116, 5, -521, 11, 1093 - 17, -521, -521, 624, -521, -521, -521, -521, -521, -33, 1094 - -521, 19, 16, -521, -521, 20, -521, -521, -298, -462, 1095 - -49, 32, 30, -235, -521, -521, -521, -495, -521, -520, 1096 - -521, -448, -521, -521, -521, 22, -521, 456, -521, 392, 1097 - 1, -31, -521, 7, -521 1103 + -560, -560, -560, 320, -560, -46, -560, -317, -315, 0, 1104 + -560, -560, -560, -560, -560, 208, -560, -560, -560, 10, 1105 + -514, -560, -560, -261, -242, -203, -2, -560, -560, -272, 1106 + 354, -66, -560, -560, -560, -560, 198, 13, 366, 137, 1107 + -195, -560, -264, -280, -560, -560, -560, -560, -41, -237, 1108 + -560, 233, -560, 25, -69, -560, 42, 99, 5, -560, 1109 + 11, 17, -560, -560, 619, -560, -560, -560, -560, -560, 1110 + -18, -560, 19, 16, -560, -560, 20, -560, -560, -307, 1111 + -496, -52, -43, -30, -236, -560, -560, -560, -540, -560, 1112 + -559, -560, 51, -560, -560, -560, 3, -560, 459, -560, 1113 + 391, 1, -50, -560, 7, -560, 615, 112, -560, -560, 1114 + 115, -560, 348 1098 1115 }; 1099 1116 1100 1117 /* YYDEFGOTO[NTERM-NUM]. */ 1101 1118 static const yytype_int16 yydefgoto[] = 1102 1119 { 1103 - -1, 1, 2, 324, 205, 543, 331, 229, 302, 42, 1104 - 455, 43, 44, 45, 46, 303, 213, 47, 304, 447, 1105 - 448, 449, 450, 516, 49, 313, 201, 380, 202, 353, 1106 - 517, 676, 682, 341, 342, 343, 251, 393, 394, 373, 1107 - 374, 375, 377, 347, 458, 462, 349, 687, 688, 555, 1108 - 52, 632, 84, 518, 53, 86, 54, 305, 56, 306, 1109 - 307, 323, 427, 59, 60, 326, 433, 61, 232, 62, 1110 - 63, 308, 309, 218, 66, 310, 68, 69, 70, 332, 1111 - 71, 234, 72, 248, 249, 580, 639, 581, 582, 519, 1112 - 612, 520, 521, 545, 658, 629, 630, 250, 409, 203, 1113 - 252, 74, 75, 254, 415 1120 + -1, 1, 43, 2, 338, 212, 562, 345, 236, 316, 1121 + 45, 474, 46, 47, 48, 49, 317, 220, 50, 318, 1122 + 464, 465, 466, 467, 535, 52, 327, 208, 397, 209, 1123 + 370, 536, 703, 709, 358, 359, 360, 258, 410, 411, 1124 + 390, 391, 392, 394, 364, 477, 481, 366, 714, 715, 1125 + 574, 55, 657, 91, 537, 56, 93, 57, 319, 59, 1126 + 320, 321, 337, 444, 62, 63, 340, 450, 64, 239, 1127 + 65, 66, 322, 323, 225, 69, 324, 71, 72, 73, 1128 + 346, 74, 241, 75, 255, 256, 602, 664, 603, 604, 1129 + 538, 634, 539, 540, 564, 684, 654, 655, 257, 426, 1130 + 210, 259, 77, 78, 261, 432, 81, 585, 586, 82, 1131 + 83, 267, 268 1114 1132 }; 1115 1133 1116 1134 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If ··· 1118 1136 number is the opposite. If YYTABLE_NINF, syntax error. */ 1119 1137 static const yytype_int16 yytable[] = 1120 1138 { 1121 - 50, 219, 41, 73, 247, 206, 246, 55, 381, 76, 1122 - 333, 334, 48, 57, 389, 51, 312, 217, 65, 58, 1123 - 423, 64, 67, 418, 567, 679, 436, 376, 478, -259, 1124 - 376, 338, 97, 99, 440, 12, 263, 388, 680, 498, 1125 - 395, 253, 430, 610, 25, 382, 395, 402, 385, 628, 1126 - 387, 220, 608, 392, -259, 215, 174, 221, 399, 502, 1127 - 178, 298, 261, 214, 523, 607, 499, 659, 523, 613, 1128 - 351, 443, 79, 352, 325, 238, 25, 239, -259, 634, 1129 - -43, 413, 414, 299, 640, 264, 503, 192, 10, 3, 1130 - 85, 524, 660, 376, 446, 530, 87, 441, 235, 235, 1131 - 235, 236, 237, -259, 235, 637, 255, 336, 91, 92, 1132 - 336, 240, 337, 16, 635, 614, 10, 476, 477, 478, 1133 - 479, 480, 481, 482, 468, 469, 470, 471, 472, 473, 1134 - 474, 478, 426, 93, 546, 431, 90, 40, 21, 628, 1135 - 663, 94, 651, 241, 541, 336, 560, 647, 95, 432, 1136 - 642, 40, 247, 100, 246, 686, 457, 431, 431, 77, 1137 - 646, 78, 238, 649, 239, 238, 40, 239, 204, 425, 1138 - 669, 459, 463, 40, 664, 80, 456, 81, 247, 247, 1139 - 246, 246, 40, 29, 82, 460, 83, 207, -38, 544, 1140 - 666, 344, 222, 681, 327, 34, 223, 242, 240, 671, 1141 - 354, 240, 471, 50, 50, 231, 73, 73, 97, 99, 1142 - 226, 224, 76, 76, 496, 497, 677, 257, 51, 51, 1143 - 478, 88, 228, 89, 243, 566, 96, 568, 83, 225, 1144 - 241, 391, 227, 241, 583, 584, 230, 586, 587, 588, 1145 - 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 1146 - 599, 600, 601, 602, 624, 604, 400, 578, 98, 403, 1147 - 83, 410, 411, 424, 244, 247, 417, 246, 625, 355, 1148 - 605, 233, 356, 357, 358, 359, 360, 361, 390, 258, 1149 - 245, 395, 260, 235, 242, 339, -40, 242, 391, 487, 1150 - 488, 489, 490, 491, 492, 493, 494, 495, 627, -259, 1151 - 617, -39, -259, 615, -41, 496, 497, 493, 494, 495, 1152 - 440, 243, 262, 256, 243, 622, -42, 496, 497, 476, 1153 - 477, 478, 314, 475, 83, 315, 259, 316, 653, 439, 1154 - 265, 438, 73, 266, 267, 390, 362, 440, 76, 268, 1155 - 317, 513, 318, 238, 51, 239, 319, 461, 83, 440, 1156 - 320, 514, 83, 328, 244, 329, 578, 247, 238, 246, 1157 - 239, 578, 336, 269, 643, 673, 440, 515, 270, 271, 1158 - 245, 404, 405, 406, 407, 408, -252, 240, -252, 240, 1159 - 40, 272, 550, 363, 10, 344, 655, 273, 274, -44, 1160 - 219, 275, 276, 674, 491, 492, 493, 494, 495, 668, 1161 - 277, 278, 670, 279, 280, 281, 496, 497, 569, 241, 1162 - 579, 241, 321, 282, 364, 376, -45, 578, 574, 283, 1163 - 284, 285, 286, 287, 8, 288, 50, 365, 41, 73, 1164 - 289, 554, 551, 55, 439, 76, 438, 73, 48, 57, 1165 - 220, 51, 547, 76, 65, 58, 221, 64, 67, 51, 1166 - 611, 683, 214, 366, 290, 291, 367, 368, 444, 292, 1167 - 293, 370, 371, 242, 570, 242, 391, 19, 294, 295, 1168 - 445, 296, 297, 345, 372, -46, 330, 335, 340, 346, 1169 - 22, 23, 24, 247, 348, 246, 350, 378, 379, 26, 1170 - 243, 383, 243, 431, 431, 491, 492, 493, 494, 495, 1171 - 384, 620, 386, 396, 633, 219, 398, 496, 497, 579, 1172 - 416, 419, 638, 390, 579, 391, 429, 420, 421, 422, 1173 - 476, 477, 478, 479, 480, 481, 482, 434, 391, 31, 1174 - 576, -259, 514, 33, 435, 452, 442, 240, 453, 451, 1175 - 454, 336, 10, 336, 464, 465, 577, 467, 515, 528, 1176 - 466, 500, 542, 501, 247, 504, 246, 505, 506, 549, 1177 - 507, 508, 390, 509, 20, 391, 510, 512, 522, 241, 1178 - 579, 525, 526, 527, 529, 390, 537, 532, 355, 533, 1179 - 5, 356, 357, 358, 359, 360, 361, 534, 535, 536, 1180 - 538, 539, 540, 391, 552, 557, 564, 355, 572, 563, 1181 - 356, 357, 358, 359, 360, 361, 571, 6, 573, 7, 1182 - 585, 603, 390, 606, 619, 8, 618, 621, 50, 10, 1183 - 623, 73, 439, 242, 438, 73, 631, 76, 657, 641, 1184 - 648, 76, 650, 51, 652, 13, 661, 51, 662, 665, 1185 - 390, 208, 15, 667, 16, 362, 672, 678, 17, 355, 1186 - 243, 18, 356, 357, 358, 359, 360, 361, 19, 684, 1187 - 685, 690, 558, 412, 362, 401, 616, 689, 565, 21, 1188 - 556, 22, 23, 24, 216, 322, 397, 0, 0, 0, 1189 - 26, 675, 0, 0, 428, 0, 0, 0, 0, 0, 1190 - 576, 0, 363, 488, 489, 490, 491, 492, 493, 494, 1191 - 495, 336, 0, 0, 0, 0, 577, 0, 496, 497, 1192 - 0, 363, 0, 0, 29, 0, 362, 0, 0, 30, 1193 - 31, 32, 0, 364, 33, 0, 34, 0, 0, 0, 1194 - 211, 0, 476, 477, 478, 0, 365, 481, 482, 212, 1195 - 0, 37, 364, 0, 0, 0, 0, 0, 0, 38, 1196 - 39, 0, 0, 0, 0, 365, 0, 0, 0, 0, 1197 - 0, 0, 366, 363, 0, 367, 368, 369, 0, 0, 1198 - 370, 371, 0, 0, 0, 0, 0, 0, 0, 0, 1199 - 0, 366, 0, 372, 367, 368, 369, 0, 0, 370, 1200 - 371, 0, 0, 0, 364, 4, 5, 0, 561, 0, 1201 - 0, 0, 372, 0, 0, 0, 0, 365, 0, 0, 1202 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1203 - 0, 0, 0, 6, 0, 7, 0, 0, 0, 0, 1204 - 0, 8, 9, 366, 0, 10, 367, 368, 369, 0, 1205 - 11, 370, 371, 0, 0, 0, 0, 0, 0, 12, 1206 - 0, 13, 0, 0, 372, 0, 0, 14, 15, 0, 1207 - 16, 0, 0, 0, 17, 0, 0, 18, 0, 0, 1208 - 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 1209 - 0, 20, 301, 0, 0, 21, 0, 22, 23, 24, 1210 - 25, 0, 0, 0, 0, 0, 26, 0, 0, 0, 1211 - 0, 27, 0, 0, 0, 0, 489, 490, 491, 492, 1212 - 493, 494, 495, 4, 5, 0, 0, 0, 28, 0, 1213 - 496, 497, 0, 0, 0, 0, 0, 0, 0, 0, 1214 - 29, 0, 0, 0, 0, 30, 31, 32, 0, 0, 1215 - 33, 6, 34, 7, 0, 0, 35, 0, 0, 8, 1216 - 9, 0, 0, 10, 0, 36, 0, 37, 11, 0, 1217 - 0, 0, 0, 0, 0, 38, 39, 12, 0, 13, 1218 - 0, 0, 0, 0, 0, 14, 15, 0, 16, 0, 1219 - 0, 0, 17, 0, 0, 18, 0, 0, 0, 0, 1220 - 0, 0, 19, 0, 40, 0, 0, 311, 0, 20, 1221 - 301, 0, 0, 21, 0, 22, 23, 24, 25, 0, 1222 - 0, 0, 0, 0, 26, 0, 0, 0, 0, 27, 1223 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1224 - 0, 4, 5, 0, 0, 0, 28, 0, 0, 0, 1225 - 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 1226 - 0, 0, 0, 30, 31, 32, 0, 0, 33, 6, 1227 - 34, 7, 0, 0, 35, 0, 0, 8, 9, 0, 1228 - 0, 10, 0, 36, 0, 37, 11, 0, 0, 0, 1229 - 0, 0, 0, 38, 39, 12, 0, 13, 0, 0, 1230 - 0, 0, 0, 14, 15, 0, 16, 0, 0, 0, 1231 - 17, 0, 0, 18, 0, 0, 0, 0, 0, 0, 1232 - 19, 0, 40, 0, 0, 654, 0, 20, 0, 0, 1233 - 0, 21, 0, 22, 23, 24, 25, 0, 0, 0, 1234 - 0, 0, 26, 0, 4, 5, 0, 27, 0, 0, 1139 + 53, 226, 44, 76, 213, 254, 398, 58, 253, 79, 1140 + 440, 326, 51, 60, 352, 54, 347, 348, 68, 61, 1141 + 632, 67, 70, 399, 589, 260, 402, 453, 404, 243, 1142 + 244, 409, 653, 406, 262, 224, 416, 630, 706, 457, 1143 + 435, 242, 242, 242, -404, 447, 277, 242, 13, 517, 1144 + 275, 707, 312, 497, 227, 245, 659, 246, 222, 27, 1145 + 228, 665, 104, 106, -261, 354, 221, -261, 181, 460, 1146 + 97, 497, 185, 521, 313, 101, 518, 245, 542, 246, 1147 + 245, 685, 246, 42, 542, 662, 442, 355, 393, 339, 1148 + 27, 393, 247, 368, 3, 278, 369, 11, 405, 199, 1149 + 522, 412, 660, 449, 350, 543, 686, 412, 419, 351, 1150 + 458, 549, 264, -261, 247, -45, -261, 247, 350, 11, 1151 + 689, 86, 676, 636, 248, 265, 653, 565, 478, 482, 1152 + 266, 350, 92, 102, 443, 672, 667, 448, 107, 579, 1153 + 42, 421, 422, 423, 424, 425, 248, 42, 80, 248, 1154 + 84, 713, 85, 695, 393, 463, 42, 254, 94, 475, 1155 + 253, 476, 448, 448, 560, 690, 42, 98, 87, 479, 1156 + 88, 231, 89, 11, 90, 95, 99, 96, 245, 249, 1157 + 246, 100, 211, 254, 254, 214, 253, 253, 487, 488, 1158 + 489, 490, 491, 492, 493, 103, -40, 90, 17, 229, 1159 + 105, 249, 90, 361, 249, 563, 250, 708, 588, 232, 1160 + 53, 53, 371, 76, 76, 247, 341, 353, 230, 79, 1161 + 79, 233, -261, 22, -41, 54, 54, 238, 250, 590, 1162 + 242, 250, 235, 495, 496, 497, 498, 499, 500, 501, 1163 + 515, 516, 408, 104, 106, 234, 251, 248, 512, 513, 1164 + 514, 417, 600, 627, 420, 237, 427, 428, 515, 516, 1165 + 646, 434, 252, 647, 240, -261, 490, -43, 533, 31, 1166 + 328, 533, 90, 329, 441, 330, 331, 254, 332, 350, 1167 + 253, 36, 350, 639, 534, -42, 333, 534, 90, 334, 1168 + 263, 90, 407, 342, 245, 343, 246, -44, 637, 408, 1169 + 605, 606, 249, 608, 609, 610, 611, 612, 613, 614, 1170 + 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 1171 + 270, 626, 649, 457, 271, -254, 678, -254, 272, 250, 1172 + 430, 431, 273, 644, 274, 497, 276, 494, 42, 349, 1173 + 279, 280, 281, 456, 282, 455, 76, 412, 283, 407, 1174 + 284, 285, 79, 457, 600, 532, 286, -46, 54, 600, 1175 + 287, 288, 668, 289, 480, 457, 699, 290, 291, 251, 1176 + 292, 293, 254, 294, 9, 253, 295, 296, 297, 356, 1177 + 298, 299, -47, 457, 300, 252, 495, 496, 497, 498, 1178 + 499, 500, 501, 502, 503, 301, 569, 302, 303, 304, 1179 + 305, 306, 361, 701, 226, 307, 308, 680, 508, 509, 1180 + 510, 511, 512, 513, 514, 247, 309, 20, 600, 310, 1181 + 11, 311, 515, 516, 591, -48, 357, 335, 601, 344, 1182 + 23, 24, 25, 26, 596, 362, 363, 365, 367, 395, 1183 + 28, 396, 710, 53, 400, 44, 76, 248, 573, 570, 1184 + 58, 456, 79, 455, 76, 51, 60, 227, 54, 566, 1185 + 79, 68, 61, 228, 67, 70, 54, 401, 633, 221, 1186 + 403, 694, 413, 415, 696, 433, 436, 459, 437, 446, 1187 + 33, 438, 408, 592, 35, 439, -261, 471, 393, 451, 1188 + 470, 452, 469, 472, 473, 547, 556, 495, 496, 497, 1189 + 254, 561, 249, 253, 21, 483, 484, 485, 448, 448, 1190 + 510, 511, 512, 513, 514, 486, 642, 519, 520, 523, 1191 + 524, 226, 515, 516, 658, 525, 568, 526, 527, 250, 1192 + 601, 408, 407, 663, 528, 601, 247, 529, 531, 541, 1193 + 544, 545, 576, 546, 584, 372, 548, 408, 373, 374, 1194 + 375, 376, 377, 378, 551, 552, 504, 553, 505, 506, 1195 + 507, 508, 509, 510, 511, 512, 513, 514, 248, 598, 1196 + 554, 555, 557, 558, 254, 515, 516, 253, 559, 571, 1197 + 350, 407, 530, 629, 408, 599, 583, 635, 582, 593, 1198 + 495, 496, 497, 594, 601, 500, 501, 407, 595, 372, 1199 + 607, 5, 373, 374, 375, 376, 377, 378, 625, 628, 1200 + 640, 641, 643, 379, 372, 408, 645, 373, 374, 375, 1201 + 376, 377, 378, 249, 80, 651, 666, 656, 682, 7, 1202 + 683, 8, 673, 675, 407, 677, 688, 9, 687, 711, 1203 + 53, 11, 700, 76, 456, 691, 455, 76, 693, 79, 1204 + 250, 698, 705, 79, 712, 54, 717, 14, 445, 54, 1205 + 577, 380, 429, 215, 16, 407, 17, 379, 418, 587, 1206 + 18, 716, 223, 19, 510, 511, 512, 513, 514, 638, 1207 + 20, 671, 379, 575, 674, 336, 515, 516, 702, 414, 1208 + 598, 22, 381, 23, 24, 25, 26, 269, 652, 650, 1209 + 0, 350, 468, 28, 0, 382, 599, 0, 0, 0, 1210 + 0, 0, 0, 372, 692, 380, 373, 374, 375, 376, 1211 + 377, 378, 0, 697, 0, 0, 0, 0, 0, 0, 1212 + 380, 383, 0, 0, 384, 385, 461, 31, 0, 387, 1213 + 388, 704, 32, 33, 34, 0, 381, 35, 462, 36, 1214 + 0, 0, 389, 218, 0, 0, 0, 0, 0, 382, 1215 + 0, 381, 219, 0, 39, 508, 509, 510, 511, 512, 1216 + 513, 514, 40, 41, 382, 0, 0, 0, 0, 515, 1217 + 516, 379, 0, 0, 0, 383, 0, 0, 384, 385, 1218 + 386, 0, 0, 387, 388, 0, 0, 0, 0, 0, 1219 + 383, 0, 0, 384, 385, 386, 389, 0, 387, 388, 1220 + 0, 0, 0, 0, 0, 0, 0, 580, 0, 0, 1221 + 0, 389, 0, 0, 0, 0, 0, 0, 0, 380, 1235 1222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1236 - 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 1237 - 0, 0, 6, 0, 7, 0, 29, 0, 0, 0, 1238 - 8, 30, 31, 32, 10, 0, 33, 0, 34, 11, 1239 - 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 1240 - 13, 36, 0, 37, 0, 0, 14, 15, 0, 16, 1241 - 0, 38, 39, 17, 0, 0, 18, 0, 0, 0, 1242 - 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 1243 - 20, 0, 0, 0, 21, 0, 22, 23, 24, 0, 1244 - 40, 0, 0, 548, 0, 26, 0, 4, 5, 0, 1245 1223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1246 - 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 1247 - 0, 0, 0, 0, 0, 6, 0, 7, 0, 29, 1248 - 0, 0, 0, 8, 30, 31, 32, 10, 0, 33, 1249 - 0, 34, 11, 0, 0, 35, 0, 0, 0, 0, 1250 - 0, 0, 0, 13, 36, 0, 37, 0, 0, 14, 1251 - 15, 0, 16, 0, 38, 39, 17, 0, 0, 18, 1252 - 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 1253 - 0, 0, 0, 20, 0, 0, 0, 21, 0, 22, 1254 - 23, 24, 0, 40, 0, 0, 437, 0, 26, 0, 1255 - 4, 5, 0, 0, 0, 0, 0, 0, 476, 477, 1256 - 478, 479, 480, 481, 482, 483, 484, 0, 0, 0, 1257 - 28, 0, 0, 0, 0, 0, 0, 0, 6, 0, 1258 - 7, 0, 29, 0, 0, 0, 8, 30, 31, 32, 1259 - 10, 0, 33, 0, 34, 11, 0, 0, 35, 0, 1260 - 0, 0, 0, 0, 0, 0, 13, 36, 0, 37, 1261 - 0, 0, 14, 15, 0, 16, 0, 38, 39, 17, 1262 - 0, 0, 18, 0, 0, 5, 0, 0, 0, 19, 1263 - 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 1264 - 21, 0, 22, 23, 24, 0, 40, 0, 0, 559, 1265 - 0, 26, 6, 0, 7, 0, 0, 0, 0, 0, 1266 - 8, 0, 0, 0, 10, 0, 0, 0, 0, 0, 1267 - 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 1268 - 13, 0, 0, 0, 0, 29, 208, 15, 0, 16, 1269 - 30, 31, 32, 17, 0, 33, 18, 34, 0, 0, 1270 - 0, 35, 0, 19, 0, 0, 0, 0, 0, 0, 1271 - 36, 0, 37, 0, 21, 0, 22, 23, 24, 0, 1272 - 38, 39, 0, 0, 0, 26, 0, 485, 0, 486, 1273 - 487, 488, 489, 490, 491, 492, 493, 494, 495, 0, 1274 - 0, 0, 4, 5, 0, 0, 496, 497, 0, 40, 1275 - 0, 300, 656, 511, 0, 0, 0, 0, 0, 29, 1276 - 0, 0, 0, 0, 30, 31, 32, 0, 0, 33, 1277 - 6, 34, 7, 0, 0, 211, 0, 0, 8, 9, 1278 - 0, 0, 10, 0, 212, 0, 37, 11, 0, 0, 1279 - 0, 0, 0, 0, 38, 39, 12, 0, 13, 0, 1280 - 0, 0, 0, 0, 14, 15, 0, 16, 0, 0, 1281 - 0, 17, 0, 0, 18, 0, 0, 0, 0, 0, 1282 - 0, 19, 0, 40, 0, 0, 553, 0, 20, 301, 1283 - 0, 0, 21, 0, 22, 23, 24, 25, 0, 0, 1284 - 0, 0, 0, 26, 0, 0, 0, 0, 27, 0, 1224 + 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 1225 + 381, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1226 + 0, 0, 0, 382, 0, 0, 0, 0, 0, 0, 1227 + 0, 0, 0, 0, 7, 0, 8, 0, 0, 0, 1228 + 0, 0, 9, 10, 0, 0, 11, 0, 0, 383, 1229 + 0, 12, 384, 385, 386, 0, 0, 387, 388, 0, 1230 + 13, 0, 14, 0, 0, 0, 0, 0, 15, 16, 1231 + 389, 17, 0, 0, 0, 18, 0, 0, 19, 0, 1232 + 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 1233 + 0, 0, 21, 315, 0, 0, 22, 0, 23, 24, 1234 + 25, 26, 27, 0, 0, 0, 0, 0, 28, 0, 1235 + 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 1236 + 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 1237 + 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1238 + 0, 0, 31, 0, 0, 0, 0, 32, 33, 34, 1239 + 0, 0, 35, 7, 36, 8, 0, 0, 37, 0, 1240 + 0, 9, 10, 0, 0, 11, 0, 38, 0, 39, 1241 + 12, 0, 0, 0, 0, 0, 0, 40, 41, 13, 1242 + 0, 14, 0, 0, 0, 0, 0, 15, 16, 0, 1243 + 17, 0, 0, 0, 18, 0, 0, 19, 0, 0, 1244 + 0, 0, 0, 0, 20, 0, 42, 0, 0, 325, 1245 + 0, 21, 315, 0, 0, 22, 0, 23, 24, 25, 1246 + 26, 27, 0, 0, 0, 0, 0, 28, 0, 0, 1247 + 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 1248 + 0, 0, 0, 4, 5, 0, 0, 0, 0, 30, 1285 1249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1286 - 4, 5, 0, 0, 0, 28, 0, 0, 0, 0, 1287 - 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 1288 - 0, 0, 30, 31, 32, 0, 0, 33, 6, 34, 1289 - 7, 0, 0, 35, 0, 0, 8, 9, 0, 0, 1290 - 10, 0, 36, 0, 37, 11, 0, 0, 0, 0, 1291 - 0, 0, 38, 39, 12, 0, 13, 0, 0, 0, 1292 - 0, 0, 14, 15, 0, 16, 0, 0, 0, 17, 1293 - 0, 0, 18, 0, 0, 0, 0, 0, 0, 19, 1294 - 0, 40, 0, 0, 0, 0, 20, 0, 0, 0, 1295 - 21, 0, 22, 23, 24, 25, 0, 0, 0, 0, 1296 - 0, 26, 0, 0, 0, 0, 27, 0, 0, 0, 1250 + 0, 31, 0, 0, 0, 0, 32, 33, 34, 0, 1251 + 0, 35, 7, 36, 8, 0, 0, 37, 0, 0, 1252 + 9, 10, 0, 0, 11, 0, 38, 0, 39, 12, 1253 + 0, 0, 0, 0, 0, 0, 40, 41, 13, 0, 1254 + 14, 0, 0, 0, 0, 0, 15, 16, 0, 17, 1255 + 0, 0, 0, 18, 0, 0, 19, 0, 0, 0, 1256 + 0, 0, 0, 20, 0, 42, 0, 0, 679, 0, 1257 + 21, 0, 0, 0, 22, 0, 23, 24, 25, 26, 1258 + 27, 0, 0, 0, 0, 0, 28, 4, 5, 0, 1259 + 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 1260 + 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 1261 + 0, 0, 0, 0, 0, 0, 7, 0, 8, 0, 1262 + 31, 0, 0, 0, 9, 32, 33, 34, 11, 0, 1263 + 35, 0, 36, 12, 0, 0, 37, 0, 0, 0, 1264 + 0, 0, 0, 0, 14, 38, 0, 39, 0, 0, 1265 + 15, 16, 0, 17, 0, 40, 41, 18, 0, 0, 1266 + 19, 0, 0, 0, 0, 0, 0, 20, 0, 0, 1267 + 0, 0, 0, 0, 21, 0, 0, 0, 22, 0, 1268 + 23, 24, 25, 26, 42, 0, 0, 567, 0, 0, 1269 + 28, 4, 5, 0, 0, 0, 0, 0, 0, 0, 1297 1270 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1298 - 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 1299 - 5, 0, 0, 0, 0, 29, 0, 0, 0, 0, 1300 - 30, 31, 32, 0, 0, 33, 0, 34, 0, 0, 1301 - 0, 35, 0, 0, 0, 0, 0, 6, -66, 7, 1302 - 36, 0, 37, 0, 240, 8, 0, 0, 0, 10, 1303 - 38, 39, 0, 0, 0, 0, 0, 0, 0, 0, 1304 - 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 1305 - 0, 208, 15, 0, 16, 0, 241, 0, 17, 40, 1306 - 0, 18, 0, 0, 0, 0, 0, 0, 19, 0, 1307 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 1308 - 0, 22, 23, 24, 0, 0, 0, 0, 0, 0, 1309 - 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1271 + 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 1272 + 7, 0, 8, 0, 31, 0, 0, 0, 9, 32, 1273 + 33, 34, 11, 0, 35, 0, 36, 12, 0, 0, 1274 + 37, 0, 0, 0, 0, 0, 0, 0, 14, 38, 1275 + 0, 39, 0, 0, 15, 16, 0, 17, 0, 40, 1276 + 41, 18, 0, 0, 19, 0, 0, 0, 0, 0, 1277 + 0, 20, 0, 0, 0, 0, 0, 0, 21, 0, 1278 + 0, 0, 22, 0, 23, 24, 25, 26, 42, 0, 1279 + 0, 454, 0, 0, 28, 4, 5, 0, 0, 0, 1280 + 0, 0, 495, 496, 497, 498, 499, 500, 501, 502, 1281 + 503, 0, 0, 0, 0, 0, 30, 0, 0, 0, 1282 + 0, 0, 0, 0, 7, 0, 8, 0, 31, 0, 1283 + 0, 0, 9, 32, 33, 34, 11, 0, 35, 0, 1284 + 36, 12, 0, 0, 37, 0, 0, 0, 0, 0, 1285 + 0, 0, 14, 38, 0, 39, 0, 0, 15, 16, 1286 + 0, 17, 0, 40, 41, 18, 0, 0, 19, 0, 1287 + 0, 5, 0, 0, 0, 20, 0, 0, 0, 0, 1288 + 0, 0, 21, 0, 0, 0, 22, 0, 23, 24, 1289 + 25, 26, 42, 0, 0, 578, 0, 0, 28, 7, 1290 + 0, 8, 0, 0, 0, 0, 0, 9, 0, 0, 1291 + 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 1292 + 30, 0, 0, 0, 0, 0, 0, 14, 0, 0, 1293 + 0, 0, 31, 215, 16, 0, 17, 32, 33, 34, 1294 + 18, 0, 35, 19, 36, 0, 0, 0, 37, 0, 1295 + 20, 0, 0, 0, 0, 0, 0, 38, 0, 39, 1296 + 0, 22, 0, 23, 24, 25, 26, 40, 41, 0, 1297 + 0, 0, 504, 28, 505, 506, 507, 508, 509, 510, 1298 + 511, 512, 513, 514, 0, 0, 0, 0, 0, 0, 1299 + 0, 515, 516, 0, 0, 0, 42, 0, 550, 681, 1300 + 4, 5, 0, 0, 0, 0, 0, 31, 0, 0, 1301 + 6, 0, 32, 33, 34, 0, 0, 35, 0, 36, 1302 + 0, 0, 0, 218, 0, 0, 0, 0, 0, 7, 1303 + 0, 8, 219, 0, 39, 0, 0, 9, 10, 0, 1304 + 0, 11, 40, 41, 0, 0, 12, 0, 0, 0, 1305 + 0, 0, 0, 0, 0, 13, 0, 14, 0, 0, 1306 + 0, 0, 0, 15, 16, 0, 17, 0, 0, 0, 1307 + 18, 42, 0, 19, 572, 0, 0, 0, 0, 0, 1308 + 20, 0, 0, 0, 0, 0, 0, 21, 0, 0, 1309 + 0, 22, 0, 23, 24, 25, 26, 27, 0, 0, 1310 + 0, 0, 0, 28, 0, 0, 0, 0, 29, 0, 1310 1311 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1311 - 242, 0, 0, 0, 0, 0, 0, 0, 5, 0, 1312 - 0, 0, 0, 0, 29, 0, 0, 0, 0, 30, 1313 - 31, 32, 0, 0, 33, 0, 34, 243, 0, 0, 1314 - 211, 0, 0, 0, 0, 6, 0, 7, 0, 212, 1315 - 0, 37, 240, 8, 0, 0, 0, 10, 0, 38, 1316 - 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1317 - 0, 0, 0, 13, 0, 0, 0, 609, 0, 208, 1318 - 15, 0, 16, 0, 241, 0, 17, 0, 40, 18, 1319 - 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 1320 - 0, 0, 0, 0, 0, 0, 0, 21, 0, 22, 1321 - 23, 24, 0, 0, 0, 0, 0, 0, 26, 0, 1322 - 0, 5, 0, 0, 0, 476, 477, 478, 479, 480, 1323 - 481, 482, 483, 484, 0, 0, 0, 0, 242, 626, 1324 - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 1325 - 7, 0, 29, 0, 0, 0, 8, 30, 31, 32, 1326 - 10, 0, 33, 0, 34, 243, 0, 0, 211, 0, 1327 - 0, 0, 0, 0, 0, 0, 13, 212, 0, 37, 1328 - 0, 0, 208, 15, 0, 16, 0, 38, 39, 17, 1329 - 0, 0, 18, 0, 0, 5, 0, 0, 0, 19, 1330 - 0, 0, 0, 0, 0, 636, 0, 0, 0, 0, 1331 - 21, 0, 22, 23, 24, 0, 40, 0, 0, 0, 1332 - 0, 26, 6, 0, 7, 0, 0, 0, 0, 0, 1333 - 8, 0, 0, 0, 10, 476, 477, 478, 479, 480, 1334 - 481, 482, 483, 484, 0, 0, 0, 0, 0, 0, 1335 - 13, 0, 0, 0, 0, 29, 208, 15, 0, 16, 1336 - 30, 31, 32, 17, 0, 33, 18, 34, 0, 0, 1337 - 0, 211, 0, 19, 0, 0, 0, 0, 0, 0, 1338 - 212, 0, 37, 0, 21, 0, 22, 23, 24, 0, 1339 - 38, 39, 0, 0, 485, 26, 486, 487, 488, 489, 1340 - 490, 491, 492, 493, 494, 495, 0, 0, 0, 0, 1341 - 0, 0, 0, 496, 497, 0, 0, 0, 0, 40, 1342 - 531, 0, 476, 477, 478, 479, 480, 481, 482, 29, 1343 - 484, 0, 0, 0, 30, 31, 32, 0, 0, 33, 1344 - 0, 34, 0, 0, 0, 211, 0, 0, 0, 0, 1345 - 0, 0, 0, 0, 212, 0, 37, 0, 0, 0, 1346 - 0, 0, 0, 0, 38, 39, 476, 477, 478, 479, 1347 - 480, 481, 482, 483, 484, 0, 0, 0, 0, 0, 1312 + 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, 1313 + 4, 5, 0, 0, 0, 0, 0, 31, 0, 314, 1314 + 0, 0, 32, 33, 34, 0, 0, 35, 0, 36, 1315 + 0, 0, 0, 37, 0, 0, 0, 0, 0, 7, 1316 + -68, 8, 38, 0, 39, 0, 0, 9, 10, 0, 1317 + 0, 11, 40, 41, 0, 0, 12, 0, 0, 0, 1318 + 0, 0, 0, 0, 0, 13, 0, 14, 0, 0, 1319 + 0, 0, 0, 15, 16, 0, 17, 0, 0, 0, 1320 + 18, 42, 0, 19, 0, 0, 0, 0, 0, 0, 1321 + 20, 0, 0, 0, 0, 0, 0, 21, 315, 0, 1322 + 0, 22, 0, 23, 24, 25, 26, 27, 5, 0, 1323 + 0, 0, 0, 28, 0, 0, 0, 0, 29, 0, 1348 1324 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1349 - 0, 0, 0, 40, 476, 477, 478, 479, 480, 481, 1350 - 482, 483, 484, 0, 485, 0, 486, 487, 488, 489, 1351 - 490, 491, 492, 493, 494, 495, 0, 0, 0, 0, 1352 - 0, 0, 0, 496, 497, 0, 0, 0, 0, 0, 1353 - 575, 476, 477, 478, 479, 480, 481, 482, 483, 484, 1325 + 0, 0, 0, 0, 0, 30, 7, 0, 8, 0, 1326 + 0, 0, 0, 247, 9, 0, 0, 31, 11, 0, 1327 + 0, 0, 32, 33, 34, 0, 0, 35, 0, 36, 1328 + 0, 0, 0, 37, 14, 0, 0, 0, 0, 0, 1329 + 215, 16, 38, 17, 39, 248, 0, 18, 0, 0, 1330 + 19, 0, 40, 41, 0, 0, 0, 20, 0, 0, 1331 + 0, 0, 0, 0, 0, 0, 5, 0, 22, 0, 1332 + 23, 24, 25, 26, 0, 0, 0, 0, 0, 0, 1333 + 28, 42, 0, 0, 0, 0, 0, 0, 0, 0, 1334 + 0, 0, 0, 0, 7, 0, 8, 0, 0, 0, 1335 + 249, 247, 9, 0, 0, 0, 11, 0, 0, 0, 1336 + 0, 0, 0, 0, 31, 0, 0, 0, 0, 32, 1337 + 33, 34, 14, 0, 35, 0, 36, 250, 215, 16, 1338 + 218, 17, 0, 248, 0, 18, 0, 0, 19, 219, 1339 + 0, 39, 0, 0, 0, 20, 0, 0, 0, 40, 1340 + 41, 0, 0, 0, 5, 0, 22, 0, 23, 24, 1341 + 25, 26, 0, 0, 0, 0, 0, 631, 28, 0, 1342 + 0, 0, 0, 648, 0, 0, 0, 0, 42, 0, 1343 + 0, 0, 7, 0, 8, 0, 0, 0, 249, 0, 1344 + 9, 0, 0, 0, 11, 0, 0, 0, 0, 0, 1345 + 0, 0, 31, 0, 0, 0, 0, 32, 33, 34, 1346 + 14, 0, 35, 0, 36, 250, 215, 16, 218, 17, 1347 + 0, 0, 0, 18, 0, 0, 19, 219, 0, 39, 1348 + 0, 0, 0, 20, 0, 0, 0, 40, 41, 0, 1349 + 0, 0, 5, 0, 22, 0, 23, 24, 25, 26, 1350 + 0, 0, 0, 0, 0, 661, 28, 495, 496, 497, 1351 + 498, 499, 500, 501, 502, 503, 42, 0, 0, 0, 1352 + 7, 0, 8, 0, 0, 0, 0, 0, 9, 0, 1353 + 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 1354 + 31, 0, 0, 0, 0, 32, 33, 34, 14, 0, 1355 + 35, 0, 36, 0, 215, 16, 218, 17, 0, 0, 1356 + 0, 18, 0, 0, 19, 219, 0, 39, 0, 0, 1357 + 0, 20, 0, 0, 0, 40, 41, 0, 0, 0, 1358 + 0, 0, 22, 0, 23, 24, 25, 26, 0, 0, 1359 + 0, 0, 0, 0, 28, 495, 496, 497, 498, 499, 1360 + 500, 501, 502, 503, 42, 0, 0, 0, 0, 0, 1361 + 0, 0, 0, 0, 0, 0, 0, 495, 496, 497, 1362 + 498, 499, 500, 501, 502, 503, 0, 0, 31, 0, 1363 + 0, 0, 0, 32, 33, 34, 0, 0, 35, 0, 1364 + 36, 0, 0, 0, 218, 0, 0, 0, 0, 0, 1365 + 0, 0, 0, 219, 0, 39, 0, 0, 0, 0, 1366 + 0, 0, 0, 40, 41, 495, 496, 497, 498, 499, 1367 + 500, 501, 502, 503, 0, 0, 0, 504, 0, 505, 1368 + 506, 507, 508, 509, 510, 511, 512, 513, 514, 0, 1369 + 0, 0, 42, 0, 0, 0, 515, 516, 0, 0, 1370 + 0, 0, 0, 597, 495, 496, 497, 498, 499, 500, 1371 + 501, 502, 503, 0, 0, 0, 0, 0, 0, 0, 1372 + 0, 0, 0, 495, 496, 497, 498, 499, 500, 501, 1373 + 0, 503, 0, 0, 0, 0, 0, 0, 0, 0, 1374 + 0, 0, 495, 496, 497, 498, 499, 500, 501, 0, 1354 1375 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1355 - 0, 0, 476, 477, 478, 479, 480, 481, 482, 483, 1356 - 484, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1357 - 0, 476, 477, 478, 479, 480, 481, 482, 476, 477, 1358 - 478, 479, 480, 481, 482, 0, 0, 0, 0, 0, 1359 - 0, 0, 0, 486, 487, 488, 489, 490, 491, 492, 1360 - 493, 494, 495, 0, 0, 0, 0, 0, 0, 0, 1361 - 496, 497, 0, 0, 0, 0, 0, 0, 0, 0, 1376 + 0, 0, 0, 0, 0, 504, 0, 505, 506, 507, 1377 + 508, 509, 510, 511, 512, 513, 514, 495, 496, 497, 1378 + 498, 499, 500, 501, 515, 516, 581, 504, 0, 505, 1379 + 506, 507, 508, 509, 510, 511, 512, 513, 514, 495, 1380 + 496, 497, 498, 499, 500, 501, 515, 516, 670, 0, 1362 1381 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1363 - 0, 0, 0, 0, 0, 485, 0, 486, 487, 488, 1364 - 489, 490, 491, 492, 493, 494, 495, 0, 0, 0, 1365 - 0, 0, 0, 0, 496, 497, 562, 0, 0, 0, 1366 - 0, 0, 0, 485, 0, 486, 487, 488, 489, 490, 1367 - 491, 492, 493, 494, 495, 0, 0, 0, 0, 0, 1368 - 0, 0, 496, 497, 645, 0, 0, 0, 0, 0, 1369 1382 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1370 - 485, 644, 486, 487, 488, 489, 490, 491, 492, 493, 1371 - 494, 495, 0, 0, 0, 0, 0, 0, 0, 496, 1372 - 497, 485, 0, 486, 487, 488, 489, 490, 491, 492, 1373 - 493, 494, 495, 0, 5, 0, 0, 0, 0, 0, 1374 - 496, 497, 486, 487, 488, 489, 490, 491, 492, 493, 1375 - 494, 495, 489, 490, 491, 492, 493, 494, 495, 496, 1376 - 497, 6, 0, 7, 0, 0, 496, 497, 0, 8, 1377 - 9, 0, 0, 10, 0, 0, 0, 0, 0, 0, 1378 - 0, 0, 0, 0, 0, 0, 0, 12, 0, 13, 1379 - 0, 0, 0, 0, 0, 208, 15, 0, 16, 0, 1380 - 0, 0, 17, 0, 0, 18, 0, 0, 5, 0, 1381 - 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 1382 - 0, 0, 0, 21, 0, 22, 23, 24, 25, 0, 1383 - 0, 209, 0, 0, 26, 6, 0, 7, 210, 0, 1384 - 0, 0, 0, 8, 0, 0, 0, 10, 0, 0, 1383 + 0, 0, 0, 0, 0, 504, 669, 505, 506, 507, 1384 + 508, 509, 510, 511, 512, 513, 514, 0, 0, 0, 1385 + 0, 0, 0, 0, 515, 516, 0, 0, 0, 0, 1385 1386 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1386 - 0, 0, 0, 13, 0, 0, 0, 0, 29, 208, 1387 - 15, 0, 16, 30, 31, 32, 17, 0, 33, 18, 1388 - 34, 0, 5, 0, 211, 0, 19, 0, 0, 0, 1389 - 0, 0, 0, 212, 0, 37, 0, 21, 0, 22, 1390 - 23, 24, 0, 38, 39, 0, 0, 0, 26, 6, 1391 - 0, 7, 0, 0, 0, 0, 0, 8, 0, 0, 1387 + 0, 0, 0, 0, 504, 0, 505, 506, 507, 508, 1388 + 509, 510, 511, 512, 513, 514, 0, 0, 0, 0, 1389 + 0, 0, 0, 515, 516, 505, 506, 507, 508, 509, 1390 + 510, 511, 512, 513, 514, 0, 0, 0, 0, 0, 1391 + 0, 0, 515, 516, 505, 506, 507, 508, 509, 510, 1392 + 511, 512, 513, 514, 0, 0, 0, 0, 0, 0, 1393 + 0, 515, 516, 0, 0, 0, 0, 0, 0, 0, 1392 1394 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1393 - 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 1394 - 0, 0, 29, 208, 15, 0, 0, 30, 31, 32, 1395 - 17, 0, 33, 18, 34, 0, 0, 0, 211, 0, 1396 - 19, 0, 0, 0, 0, 0, 0, 212, 0, 37, 1397 - 0, 0, 0, 22, 23, 24, 0, 38, 39, 0, 1398 - 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 1395 + 506, 507, 508, 509, 510, 511, 512, 513, 514, 0, 1396 + 0, 0, 5, 0, 0, 0, 515, 516, 0, 0, 1397 + 0, 0, 0, 507, 508, 509, 510, 511, 512, 513, 1398 + 514, 0, 0, 0, 0, 0, 0, 0, 515, 516, 1399 + 7, 0, 8, 0, 0, 0, 0, 0, 9, 10, 1400 + 0, 0, 11, 0, 0, 0, 0, 5, 0, 0, 1401 + 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 1402 + 0, 0, 0, 0, 215, 16, 0, 17, 0, 0, 1403 + 0, 18, 0, 0, 19, 7, 0, 8, 0, 0, 1404 + 0, 20, 0, 9, 0, 0, 0, 11, 0, 0, 1405 + 0, 0, 22, 0, 23, 24, 25, 26, 27, 0, 1406 + 0, 216, 0, 14, 28, 0, 0, 0, 217, 215, 1407 + 16, 0, 17, 0, 0, 0, 18, 0, 0, 19, 1408 + 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 1409 + 0, 0, 0, 0, 0, 0, 0, 22, 31, 23, 1410 + 24, 25, 26, 32, 33, 34, 0, 0, 35, 28, 1411 + 36, 5, 0, 0, 218, 0, 0, 0, 0, 0, 1412 + 0, 0, 0, 219, 0, 39, 0, 0, 0, 0, 1413 + 0, 0, 0, 40, 41, 0, 0, 0, 0, 7, 1414 + 0, 8, 0, 31, 0, 0, 0, 9, 32, 33, 1415 + 34, 0, 0, 35, 0, 36, 0, 0, 0, 218, 1416 + 0, 0, 0, 0, 0, 0, 0, 14, 219, 0, 1417 + 39, 0, 0, 215, 16, 0, 0, 0, 40, 41, 1418 + 18, 0, 0, 19, 0, 0, 0, 0, 0, 0, 1419 + 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1420 + 0, 0, 0, 23, 24, 25, 26, 0, 0, 0, 1421 + 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 1399 1422 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1400 1423 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1401 1424 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1402 - 0, 30, 31, 32, 0, 0, 33, 0, 0, 0, 1403 - 0, 0, 211, 0, 0, 0, 0, 0, 0, 0, 1404 - 0, 212, 0, 37, 0, 0, 0, 0, 0, 0, 1405 - 0, 38, 39, 101, 0, 102, 103, 104, 105, 106, 1406 - 107, 0, 108, 0, 0, 109, 0, 110, 0, 0, 1407 - 0, 111, 112, 0, 113, 114, 115, 116, 0, 117, 1408 - 118, 119, 120, 121, 122, 123, 124, 0, 125, 0, 1409 - 126, 127, 128, 129, 130, 0, 0, 131, 0, 0, 1410 - 0, 132, 0, 133, 134, 0, 135, 136, 137, 138, 1411 - 139, 140, 0, 141, 142, 143, 144, 145, 146, 0, 1412 - 0, 147, 0, 0, 148, 0, 0, 0, 0, 149, 1413 - 150, 0, 151, 152, 0, 153, 154, 0, 0, 0, 1414 - 155, 156, 157, 158, 159, 160, 0, 161, 162, 163, 1415 - 164, 165, 166, 167, 0, 168, 0, 169, 0, 170, 1416 - 171, 172, 173, 174, 175, 176, 177, 178, 0, 179, 1417 - 180, 181, 182, 0, 0, 0, 183, 0, 0, 184, 1418 - 0, 0, 185, 186, 0, 0, 187, 188, 189, 190, 1419 - 0, 0, 191, 0, 192, 0, 193, 194, 195, 196, 1420 - 197, 198, 199, 0, 0, 200 1425 + 0, 0, 32, 33, 34, 0, 0, 35, 0, 0, 1426 + 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 1427 + 0, 0, 219, 0, 39, 0, 0, 0, 0, 0, 1428 + 0, 0, 40, 41, 108, 0, 109, 110, 111, 112, 1429 + 113, 114, 0, 115, 0, 0, 116, 0, 117, 0, 1430 + 0, 0, 118, 119, 0, 120, 121, 122, 123, 0, 1431 + 124, 125, 126, 127, 128, 129, 130, 131, 0, 132, 1432 + 0, 133, 134, 135, 136, 137, 0, 0, 138, 0, 1433 + 0, 0, 139, 0, 140, 141, 0, 142, 143, 144, 1434 + 145, 146, 147, 0, 148, 149, 150, 151, 152, 153, 1435 + 0, 0, 154, 0, 0, 155, 0, 0, 0, 0, 1436 + 0, 156, 157, 0, 158, 159, 0, 160, 161, 0, 1437 + 0, 0, 162, 163, 164, 165, 166, 167, 0, 168, 1438 + 169, 170, 171, 172, 173, 174, 0, 175, 0, 176, 1439 + 0, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1440 + 0, 186, 187, 188, 189, 0, 0, 0, 190, 0, 1441 + 0, 191, 0, 0, 192, 193, 0, 0, 194, 195, 1442 + 196, 197, 0, 0, 198, 0, 199, 0, 200, 201, 1443 + 202, 203, 204, 205, 206, 0, 0, 207 1421 1444 }; 1422 1445 1423 1446 static const yytype_int16 yycheck[] = 1424 1447 { 1425 - 2, 50, 2, 2, 71, 47, 71, 2, 272, 2, 1426 - 245, 246, 2, 2, 280, 2, 207, 50, 2, 2, 1427 - 311, 2, 2, 298, 6, 38, 330, 269, 16, 156, 1428 - 272, 249, 35, 36, 332, 58, 156, 279, 51, 182, 1429 - 282, 72, 108, 515, 99, 273, 288, 289, 276, 569, 1430 - 278, 50, 514, 281, 156, 50, 134, 50, 286, 182, 1431 - 138, 182, 93, 50, 182, 513, 209, 182, 182, 517, 1432 - 9, 335, 208, 12, 129, 3, 99, 5, 205, 574, 1433 - 207, 6, 7, 204, 579, 205, 209, 165, 44, 0, 1434 - 96, 209, 207, 335, 336, 209, 9, 332, 68, 69, 1435 - 70, 69, 70, 205, 74, 577, 74, 203, 3, 208, 1436 - 203, 39, 208, 69, 576, 208, 44, 14, 15, 16, 1437 - 17, 18, 19, 20, 366, 367, 368, 369, 370, 371, 1438 - 372, 16, 323, 208, 425, 326, 26, 203, 94, 659, 1439 - 635, 31, 614, 71, 419, 203, 437, 609, 32, 326, 1440 - 208, 203, 219, 37, 219, 207, 347, 348, 349, 3, 1441 - 608, 5, 3, 611, 5, 3, 203, 5, 207, 206, 1442 - 642, 348, 349, 203, 636, 3, 206, 5, 245, 246, 1443 - 245, 246, 203, 139, 3, 206, 5, 162, 207, 424, 1444 - 638, 258, 207, 206, 227, 151, 207, 125, 39, 647, 1445 - 267, 39, 444, 205, 206, 184, 205, 206, 211, 212, 1446 - 207, 205, 205, 206, 202, 203, 664, 9, 205, 206, 1447 - 16, 3, 207, 5, 152, 453, 3, 209, 5, 205, 1448 - 71, 280, 205, 71, 476, 477, 207, 479, 480, 481, 1449 - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 1450 - 492, 493, 494, 495, 558, 497, 287, 475, 3, 290, 1451 - 5, 292, 293, 312, 192, 332, 297, 332, 559, 3, 1452 - 498, 205, 6, 7, 8, 9, 10, 11, 280, 205, 1453 - 208, 523, 3, 253, 125, 253, 207, 125, 337, 186, 1454 - 187, 188, 189, 190, 191, 192, 193, 194, 564, 205, 1455 - 528, 207, 205, 521, 207, 202, 203, 192, 193, 194, 1456 - 608, 152, 205, 207, 152, 550, 207, 202, 203, 14, 1457 - 15, 16, 3, 372, 5, 3, 207, 5, 619, 331, 1458 - 208, 331, 331, 208, 208, 337, 70, 635, 331, 208, 1459 - 3, 390, 5, 3, 331, 5, 3, 349, 5, 647, 1460 - 3, 192, 5, 3, 192, 5, 574, 424, 3, 424, 1461 - 5, 579, 203, 208, 582, 656, 664, 208, 208, 208, 1462 - 208, 177, 178, 179, 180, 181, 207, 39, 209, 39, 1463 - 203, 208, 431, 117, 44, 452, 621, 208, 208, 207, 1464 - 439, 208, 208, 657, 190, 191, 192, 193, 194, 641, 1465 - 208, 208, 644, 208, 208, 208, 202, 203, 457, 71, 1466 - 475, 71, 205, 208, 148, 657, 207, 635, 467, 208, 1467 - 208, 208, 208, 208, 40, 208, 428, 161, 428, 428, 1468 - 208, 433, 431, 428, 436, 428, 436, 436, 428, 428, 1469 - 439, 428, 426, 436, 428, 428, 439, 428, 428, 436, 1470 - 515, 679, 439, 187, 208, 208, 190, 191, 192, 208, 1471 - 208, 195, 196, 125, 457, 125, 515, 83, 208, 208, 1472 - 204, 208, 208, 184, 208, 207, 205, 210, 209, 209, 1473 - 96, 97, 98, 550, 208, 550, 9, 9, 9, 105, 1474 - 152, 9, 152, 684, 685, 190, 191, 192, 193, 194, 1475 - 9, 543, 9, 9, 571, 554, 9, 202, 203, 574, 1476 - 9, 203, 577, 515, 579, 564, 184, 208, 207, 205, 1477 - 14, 15, 16, 17, 18, 19, 20, 207, 577, 145, 1478 - 192, 205, 192, 149, 205, 182, 209, 39, 210, 206, 1479 - 6, 203, 44, 203, 209, 209, 208, 208, 208, 182, 1480 - 209, 209, 9, 209, 621, 209, 621, 209, 209, 184, 1481 - 209, 209, 564, 209, 90, 614, 209, 209, 209, 71, 1482 - 635, 209, 209, 209, 209, 577, 202, 209, 3, 209, 1483 - 5, 6, 7, 8, 9, 10, 11, 209, 209, 209, 1484 - 209, 209, 209, 642, 207, 206, 182, 3, 207, 209, 1485 - 6, 7, 8, 9, 10, 11, 209, 32, 207, 34, 1486 - 3, 3, 614, 9, 209, 40, 6, 182, 620, 44, 1487 - 207, 620, 624, 125, 624, 624, 207, 620, 184, 209, 1488 - 209, 624, 209, 620, 209, 60, 205, 624, 209, 209, 1489 - 642, 66, 67, 209, 69, 70, 209, 209, 73, 3, 1490 - 152, 76, 6, 7, 8, 9, 10, 11, 83, 184, 1491 - 184, 207, 435, 294, 70, 288, 523, 685, 452, 94, 1492 - 433, 96, 97, 98, 50, 219, 284, -1, -1, -1, 1493 - 105, 659, -1, -1, 324, -1, -1, -1, -1, -1, 1494 - 192, -1, 117, 187, 188, 189, 190, 191, 192, 193, 1495 - 194, 203, -1, -1, -1, -1, 208, -1, 202, 203, 1496 - -1, 117, -1, -1, 139, -1, 70, -1, -1, 144, 1497 - 145, 146, -1, 148, 149, -1, 151, -1, -1, -1, 1498 - 155, -1, 14, 15, 16, -1, 161, 19, 20, 164, 1499 - -1, 166, 148, -1, -1, -1, -1, -1, -1, 174, 1500 - 175, -1, -1, -1, -1, 161, -1, -1, -1, -1, 1501 - -1, -1, 187, 117, -1, 190, 191, 192, -1, -1, 1502 - 195, 196, -1, -1, -1, -1, -1, -1, -1, -1, 1503 - -1, 187, -1, 208, 190, 191, 192, -1, -1, 195, 1504 - 196, -1, -1, -1, 148, 4, 5, -1, 204, -1, 1505 - -1, -1, 208, -1, -1, -1, -1, 161, -1, -1, 1448 + 2, 53, 2, 2, 50, 74, 286, 2, 74, 2, 1449 + 325, 214, 2, 2, 256, 2, 252, 253, 2, 2, 1450 + 534, 2, 2, 287, 6, 75, 290, 344, 292, 72, 1451 + 73, 295, 591, 294, 77, 53, 300, 533, 39, 346, 1452 + 312, 71, 72, 73, 101, 110, 158, 77, 59, 184, 1453 + 100, 52, 184, 17, 53, 3, 596, 5, 53, 101, 1454 + 53, 601, 37, 38, 158, 184, 53, 158, 136, 349, 1455 + 28, 17, 140, 184, 206, 33, 211, 3, 184, 5, 1456 + 3, 184, 5, 205, 184, 599, 208, 206, 283, 131, 1457 + 101, 286, 40, 9, 0, 207, 12, 45, 293, 167, 1458 + 211, 296, 598, 340, 205, 211, 209, 302, 303, 210, 1459 + 346, 211, 51, 207, 40, 209, 207, 40, 205, 45, 1460 + 660, 210, 636, 210, 72, 64, 685, 442, 365, 366, 1461 + 69, 205, 97, 34, 337, 631, 210, 340, 39, 454, 1462 + 205, 179, 180, 181, 182, 183, 72, 205, 205, 72, 1463 + 3, 209, 5, 667, 349, 350, 205, 226, 9, 208, 1464 + 226, 364, 365, 366, 436, 661, 205, 3, 3, 208, 1465 + 5, 207, 3, 45, 5, 3, 210, 5, 3, 127, 1466 + 5, 210, 209, 252, 253, 164, 252, 253, 383, 384, 1467 + 385, 386, 387, 388, 389, 3, 209, 5, 70, 209, 1468 + 3, 127, 5, 272, 127, 441, 154, 208, 472, 207, 1469 + 212, 213, 281, 212, 213, 40, 234, 260, 209, 212, 1470 + 213, 209, 207, 95, 209, 212, 213, 186, 154, 211, 1471 + 260, 154, 209, 15, 16, 17, 18, 19, 20, 21, 1472 + 204, 205, 294, 218, 219, 207, 194, 72, 194, 195, 1473 + 196, 301, 494, 517, 304, 209, 306, 307, 204, 205, 1474 + 577, 311, 210, 578, 207, 207, 461, 209, 194, 141, 1475 + 3, 194, 5, 3, 326, 5, 3, 346, 5, 205, 1476 + 346, 153, 205, 547, 210, 209, 3, 210, 5, 3, 1477 + 209, 5, 294, 3, 3, 5, 5, 209, 540, 351, 1478 + 495, 496, 127, 498, 499, 500, 501, 502, 503, 504, 1479 + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 1480 + 101, 516, 583, 630, 9, 209, 641, 211, 207, 154, 1481 + 6, 7, 209, 569, 3, 17, 207, 389, 205, 212, 1482 + 210, 210, 210, 345, 210, 345, 345, 542, 210, 351, 1483 + 210, 210, 345, 660, 596, 407, 210, 209, 345, 601, 1484 + 210, 210, 604, 210, 366, 672, 681, 210, 210, 194, 1485 + 210, 210, 441, 210, 41, 441, 210, 210, 210, 5, 1486 + 210, 210, 209, 690, 210, 210, 15, 16, 17, 18, 1487 + 19, 20, 21, 22, 23, 210, 448, 210, 210, 210, 1488 + 210, 210, 471, 683, 456, 210, 210, 643, 190, 191, 1489 + 192, 193, 194, 195, 196, 40, 210, 84, 660, 210, 1490 + 45, 210, 204, 205, 476, 209, 211, 207, 494, 207, 1491 + 97, 98, 99, 100, 486, 186, 211, 210, 9, 9, 1492 + 107, 9, 706, 445, 9, 445, 445, 72, 450, 448, 1493 + 445, 453, 445, 453, 453, 445, 445, 456, 445, 443, 1494 + 453, 445, 445, 456, 445, 445, 453, 9, 534, 456, 1495 + 9, 666, 9, 9, 669, 9, 205, 211, 210, 186, 1496 + 147, 209, 534, 476, 151, 207, 207, 184, 683, 209, 1497 + 208, 207, 207, 212, 6, 184, 204, 15, 16, 17, 1498 + 569, 9, 127, 569, 91, 211, 211, 211, 711, 712, 1499 + 192, 193, 194, 195, 196, 210, 562, 211, 211, 211, 1500 + 211, 573, 204, 205, 593, 211, 186, 211, 211, 154, 1501 + 596, 583, 534, 599, 211, 601, 40, 211, 211, 211, 1502 + 211, 211, 208, 211, 164, 3, 211, 599, 6, 7, 1503 + 8, 9, 10, 11, 211, 211, 185, 211, 187, 188, 1504 + 189, 190, 191, 192, 193, 194, 195, 196, 72, 194, 1505 + 211, 211, 211, 211, 643, 204, 205, 643, 211, 209, 1506 + 205, 583, 211, 532, 636, 210, 184, 536, 211, 211, 1507 + 15, 16, 17, 209, 660, 20, 21, 599, 209, 3, 1508 + 3, 5, 6, 7, 8, 9, 10, 11, 3, 9, 1509 + 6, 211, 184, 71, 3, 667, 209, 6, 7, 8, 1510 + 9, 10, 11, 127, 205, 208, 211, 209, 5, 33, 1511 + 186, 35, 211, 211, 636, 211, 211, 41, 207, 186, 1512 + 642, 45, 209, 642, 646, 211, 646, 646, 211, 642, 1513 + 154, 211, 211, 646, 186, 642, 209, 61, 338, 646, 1514 + 452, 119, 308, 67, 68, 667, 70, 71, 302, 471, 1515 + 74, 712, 53, 77, 192, 193, 194, 195, 196, 542, 1516 + 84, 630, 71, 450, 633, 226, 204, 205, 685, 298, 1517 + 194, 95, 150, 97, 98, 99, 100, 82, 586, 584, 1518 + -1, 205, 354, 107, -1, 163, 210, -1, -1, -1, 1519 + -1, -1, -1, 3, 663, 119, 6, 7, 8, 9, 1520 + 10, 11, -1, 672, -1, -1, -1, -1, -1, -1, 1521 + 119, 189, -1, -1, 192, 193, 194, 141, -1, 197, 1522 + 198, 690, 146, 147, 148, -1, 150, 151, 206, 153, 1523 + -1, -1, 210, 157, -1, -1, -1, -1, -1, 163, 1524 + -1, 150, 166, -1, 168, 190, 191, 192, 193, 194, 1525 + 195, 196, 176, 177, 163, -1, -1, -1, -1, 204, 1526 + 205, 71, -1, -1, -1, 189, -1, -1, 192, 193, 1527 + 194, -1, -1, 197, 198, -1, -1, -1, -1, -1, 1528 + 189, -1, -1, 192, 193, 194, 210, -1, 197, 198, 1529 + -1, -1, -1, -1, -1, -1, -1, 206, -1, -1, 1530 + -1, 210, -1, -1, -1, -1, -1, -1, -1, 119, 1506 1531 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1507 - -1, -1, -1, 32, -1, 34, -1, -1, -1, -1, 1508 - -1, 40, 41, 187, -1, 44, 190, 191, 192, -1, 1509 - 49, 195, 196, -1, -1, -1, -1, -1, -1, 58, 1510 - -1, 60, -1, -1, 208, -1, -1, 66, 67, -1, 1511 - 69, -1, -1, -1, 73, -1, -1, 76, -1, -1, 1512 - -1, -1, -1, -1, 83, -1, -1, -1, -1, -1, 1513 - -1, 90, 91, -1, -1, 94, -1, 96, 97, 98, 1514 - 99, -1, -1, -1, -1, -1, 105, -1, -1, -1, 1515 - -1, 110, -1, -1, -1, -1, 188, 189, 190, 191, 1516 - 192, 193, 194, 4, 5, -1, -1, -1, 127, -1, 1517 - 202, 203, -1, -1, -1, -1, -1, -1, -1, -1, 1518 - 139, -1, -1, -1, -1, 144, 145, 146, -1, -1, 1519 - 149, 32, 151, 34, -1, -1, 155, -1, -1, 40, 1520 - 41, -1, -1, 44, -1, 164, -1, 166, 49, -1, 1521 - -1, -1, -1, -1, -1, 174, 175, 58, -1, 60, 1522 - -1, -1, -1, -1, -1, 66, 67, -1, 69, -1, 1523 - -1, -1, 73, -1, -1, 76, -1, -1, -1, -1, 1524 - -1, -1, 83, -1, 203, -1, -1, 206, -1, 90, 1525 - 91, -1, -1, 94, -1, 96, 97, 98, 99, -1, 1526 - -1, -1, -1, -1, 105, -1, -1, -1, -1, 110, 1527 1532 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1528 - -1, 4, 5, -1, -1, -1, 127, -1, -1, -1, 1529 - -1, -1, -1, -1, -1, -1, -1, -1, 139, -1, 1530 - -1, -1, -1, 144, 145, 146, -1, -1, 149, 32, 1531 - 151, 34, -1, -1, 155, -1, -1, 40, 41, -1, 1532 - -1, 44, -1, 164, -1, 166, 49, -1, -1, -1, 1533 - -1, -1, -1, 174, 175, 58, -1, 60, -1, -1, 1534 - -1, -1, -1, 66, 67, -1, 69, -1, -1, -1, 1535 - 73, -1, -1, 76, -1, -1, -1, -1, -1, -1, 1536 - 83, -1, 203, -1, -1, 206, -1, 90, -1, -1, 1537 - -1, 94, -1, 96, 97, 98, 99, -1, -1, -1, 1538 - -1, -1, 105, -1, 4, 5, -1, 110, -1, -1, 1539 - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1540 - -1, -1, -1, -1, 127, -1, -1, -1, -1, -1, 1541 - -1, -1, 32, -1, 34, -1, 139, -1, -1, -1, 1542 - 40, 144, 145, 146, 44, -1, 149, -1, 151, 49, 1543 - -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, 1544 - 60, 164, -1, 166, -1, -1, 66, 67, -1, 69, 1545 - -1, 174, 175, 73, -1, -1, 76, -1, -1, -1, 1546 - -1, -1, -1, 83, -1, -1, -1, -1, -1, -1, 1547 - 90, -1, -1, -1, 94, -1, 96, 97, 98, -1, 1548 - 203, -1, -1, 206, -1, 105, -1, 4, 5, -1, 1549 - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1550 - -1, -1, -1, -1, -1, -1, -1, 127, -1, -1, 1551 - -1, -1, -1, -1, -1, 32, -1, 34, -1, 139, 1552 - -1, -1, -1, 40, 144, 145, 146, 44, -1, 149, 1553 - -1, 151, 49, -1, -1, 155, -1, -1, -1, -1, 1554 - -1, -1, -1, 60, 164, -1, 166, -1, -1, 66, 1555 - 67, -1, 69, -1, 174, 175, 73, -1, -1, 76, 1556 - -1, -1, -1, -1, -1, -1, 83, -1, -1, -1, 1557 - -1, -1, -1, 90, -1, -1, -1, 94, -1, 96, 1558 - 97, 98, -1, 203, -1, -1, 206, -1, 105, -1, 1559 - 4, 5, -1, -1, -1, -1, -1, -1, 14, 15, 1560 - 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 1561 - 127, -1, -1, -1, -1, -1, -1, -1, 32, -1, 1562 - 34, -1, 139, -1, -1, -1, 40, 144, 145, 146, 1563 - 44, -1, 149, -1, 151, 49, -1, -1, 155, -1, 1564 - -1, -1, -1, -1, -1, -1, 60, 164, -1, 166, 1565 - -1, -1, 66, 67, -1, 69, -1, 174, 175, 73, 1566 - -1, -1, 76, -1, -1, 5, -1, -1, -1, 83, 1567 - -1, -1, -1, -1, -1, -1, 90, -1, -1, -1, 1568 - 94, -1, 96, 97, 98, -1, 203, -1, -1, 206, 1569 - -1, 105, 32, -1, 34, -1, -1, -1, -1, -1, 1570 - 40, -1, -1, -1, 44, -1, -1, -1, -1, -1, 1571 - -1, -1, -1, 127, -1, -1, -1, -1, -1, -1, 1572 - 60, -1, -1, -1, -1, 139, 66, 67, -1, 69, 1573 - 144, 145, 146, 73, -1, 149, 76, 151, -1, -1, 1574 - -1, 155, -1, 83, -1, -1, -1, -1, -1, -1, 1575 - 164, -1, 166, -1, 94, -1, 96, 97, 98, -1, 1576 - 174, 175, -1, -1, -1, 105, -1, 183, -1, 185, 1577 - 186, 187, 188, 189, 190, 191, 192, 193, 194, -1, 1578 - -1, -1, 4, 5, -1, -1, 202, 203, -1, 203, 1579 - -1, 13, 206, 209, -1, -1, -1, -1, -1, 139, 1580 - -1, -1, -1, -1, 144, 145, 146, -1, -1, 149, 1581 - 32, 151, 34, -1, -1, 155, -1, -1, 40, 41, 1582 - -1, -1, 44, -1, 164, -1, 166, 49, -1, -1, 1583 - -1, -1, -1, -1, 174, 175, 58, -1, 60, -1, 1584 - -1, -1, -1, -1, 66, 67, -1, 69, -1, -1, 1585 - -1, 73, -1, -1, 76, -1, -1, -1, -1, -1, 1586 - -1, 83, -1, 203, -1, -1, 206, -1, 90, 91, 1587 - -1, -1, 94, -1, 96, 97, 98, 99, -1, -1, 1588 - -1, -1, -1, 105, -1, -1, -1, -1, 110, -1, 1533 + -1, -1, -1, -1, -1, 4, 5, -1, -1, -1, 1534 + 150, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1535 + -1, -1, -1, 163, -1, -1, -1, -1, -1, -1, 1536 + -1, -1, -1, -1, 33, -1, 35, -1, -1, -1, 1537 + -1, -1, 41, 42, -1, -1, 45, -1, -1, 189, 1538 + -1, 50, 192, 193, 194, -1, -1, 197, 198, -1, 1539 + 59, -1, 61, -1, -1, -1, -1, -1, 67, 68, 1540 + 210, 70, -1, -1, -1, 74, -1, -1, 77, -1, 1541 + -1, -1, -1, -1, -1, 84, -1, -1, -1, -1, 1542 + -1, -1, 91, 92, -1, -1, 95, -1, 97, 98, 1543 + 99, 100, 101, -1, -1, -1, -1, -1, 107, -1, 1544 + -1, -1, -1, 112, -1, -1, -1, -1, -1, -1, 1545 + -1, -1, -1, -1, 4, 5, -1, -1, -1, -1, 1546 + 129, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1547 + -1, -1, 141, -1, -1, -1, -1, 146, 147, 148, 1548 + -1, -1, 151, 33, 153, 35, -1, -1, 157, -1, 1549 + -1, 41, 42, -1, -1, 45, -1, 166, -1, 168, 1550 + 50, -1, -1, -1, -1, -1, -1, 176, 177, 59, 1551 + -1, 61, -1, -1, -1, -1, -1, 67, 68, -1, 1552 + 70, -1, -1, -1, 74, -1, -1, 77, -1, -1, 1553 + -1, -1, -1, -1, 84, -1, 205, -1, -1, 208, 1554 + -1, 91, 92, -1, -1, 95, -1, 97, 98, 99, 1555 + 100, 101, -1, -1, -1, -1, -1, 107, -1, -1, 1556 + -1, -1, 112, -1, -1, -1, -1, -1, -1, -1, 1557 + -1, -1, -1, 4, 5, -1, -1, -1, -1, 129, 1589 1558 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1590 - 4, 5, -1, -1, -1, 127, -1, -1, -1, -1, 1591 - -1, -1, -1, -1, -1, -1, -1, 139, -1, -1, 1592 - -1, -1, 144, 145, 146, -1, -1, 149, 32, 151, 1593 - 34, -1, -1, 155, -1, -1, 40, 41, -1, -1, 1594 - 44, -1, 164, -1, 166, 49, -1, -1, -1, -1, 1595 - -1, -1, 174, 175, 58, -1, 60, -1, -1, -1, 1596 - -1, -1, 66, 67, -1, 69, -1, -1, -1, 73, 1597 - -1, -1, 76, -1, -1, -1, -1, -1, -1, 83, 1598 - -1, 203, -1, -1, -1, -1, 90, -1, -1, -1, 1599 - 94, -1, 96, 97, 98, 99, -1, -1, -1, -1, 1600 - -1, 105, -1, -1, -1, -1, 110, -1, -1, -1, 1559 + -1, 141, -1, -1, -1, -1, 146, 147, 148, -1, 1560 + -1, 151, 33, 153, 35, -1, -1, 157, -1, -1, 1561 + 41, 42, -1, -1, 45, -1, 166, -1, 168, 50, 1562 + -1, -1, -1, -1, -1, -1, 176, 177, 59, -1, 1563 + 61, -1, -1, -1, -1, -1, 67, 68, -1, 70, 1564 + -1, -1, -1, 74, -1, -1, 77, -1, -1, -1, 1565 + -1, -1, -1, 84, -1, 205, -1, -1, 208, -1, 1566 + 91, -1, -1, -1, 95, -1, 97, 98, 99, 100, 1567 + 101, -1, -1, -1, -1, -1, 107, 4, 5, -1, 1568 + -1, 112, -1, -1, -1, -1, -1, -1, -1, -1, 1569 + -1, -1, -1, -1, -1, -1, -1, -1, 129, -1, 1570 + -1, -1, -1, -1, -1, -1, 33, -1, 35, -1, 1571 + 141, -1, -1, -1, 41, 146, 147, 148, 45, -1, 1572 + 151, -1, 153, 50, -1, -1, 157, -1, -1, -1, 1573 + -1, -1, -1, -1, 61, 166, -1, 168, -1, -1, 1574 + 67, 68, -1, 70, -1, 176, 177, 74, -1, -1, 1575 + 77, -1, -1, -1, -1, -1, -1, 84, -1, -1, 1576 + -1, -1, -1, -1, 91, -1, -1, -1, 95, -1, 1577 + 97, 98, 99, 100, 205, -1, -1, 208, -1, -1, 1578 + 107, 4, 5, -1, -1, -1, -1, -1, -1, -1, 1601 1579 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1602 - -1, -1, -1, 127, -1, -1, -1, -1, -1, -1, 1603 - 5, -1, -1, -1, -1, 139, -1, -1, -1, -1, 1604 - 144, 145, 146, -1, -1, 149, -1, 151, -1, -1, 1605 - -1, 155, -1, -1, -1, -1, -1, 32, 162, 34, 1606 - 164, -1, 166, -1, 39, 40, -1, -1, -1, 44, 1607 - 174, 175, -1, -1, -1, -1, -1, -1, -1, -1, 1608 - -1, -1, -1, -1, -1, 60, -1, -1, -1, -1, 1609 - -1, 66, 67, -1, 69, -1, 71, -1, 73, 203, 1610 - -1, 76, -1, -1, -1, -1, -1, -1, 83, -1, 1611 - -1, -1, -1, -1, -1, -1, -1, -1, -1, 94, 1612 - -1, 96, 97, 98, -1, -1, -1, -1, -1, -1, 1613 - 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1580 + -1, -1, 129, -1, -1, -1, -1, -1, -1, -1, 1581 + 33, -1, 35, -1, 141, -1, -1, -1, 41, 146, 1582 + 147, 148, 45, -1, 151, -1, 153, 50, -1, -1, 1583 + 157, -1, -1, -1, -1, -1, -1, -1, 61, 166, 1584 + -1, 168, -1, -1, 67, 68, -1, 70, -1, 176, 1585 + 177, 74, -1, -1, 77, -1, -1, -1, -1, -1, 1586 + -1, 84, -1, -1, -1, -1, -1, -1, 91, -1, 1587 + -1, -1, 95, -1, 97, 98, 99, 100, 205, -1, 1588 + -1, 208, -1, -1, 107, 4, 5, -1, -1, -1, 1589 + -1, -1, 15, 16, 17, 18, 19, 20, 21, 22, 1590 + 23, -1, -1, -1, -1, -1, 129, -1, -1, -1, 1591 + -1, -1, -1, -1, 33, -1, 35, -1, 141, -1, 1592 + -1, -1, 41, 146, 147, 148, 45, -1, 151, -1, 1593 + 153, 50, -1, -1, 157, -1, -1, -1, -1, -1, 1594 + -1, -1, 61, 166, -1, 168, -1, -1, 67, 68, 1595 + -1, 70, -1, 176, 177, 74, -1, -1, 77, -1, 1596 + -1, 5, -1, -1, -1, 84, -1, -1, -1, -1, 1597 + -1, -1, 91, -1, -1, -1, 95, -1, 97, 98, 1598 + 99, 100, 205, -1, -1, 208, -1, -1, 107, 33, 1599 + -1, 35, -1, -1, -1, -1, -1, 41, -1, -1, 1600 + -1, 45, -1, -1, -1, -1, -1, -1, -1, -1, 1601 + 129, -1, -1, -1, -1, -1, -1, 61, -1, -1, 1602 + -1, -1, 141, 67, 68, -1, 70, 146, 147, 148, 1603 + 74, -1, 151, 77, 153, -1, -1, -1, 157, -1, 1604 + 84, -1, -1, -1, -1, -1, -1, 166, -1, 168, 1605 + -1, 95, -1, 97, 98, 99, 100, 176, 177, -1, 1606 + -1, -1, 185, 107, 187, 188, 189, 190, 191, 192, 1607 + 193, 194, 195, 196, -1, -1, -1, -1, -1, -1, 1608 + -1, 204, 205, -1, -1, -1, 205, -1, 211, 208, 1609 + 4, 5, -1, -1, -1, -1, -1, 141, -1, -1, 1610 + 14, -1, 146, 147, 148, -1, -1, 151, -1, 153, 1611 + -1, -1, -1, 157, -1, -1, -1, -1, -1, 33, 1612 + -1, 35, 166, -1, 168, -1, -1, 41, 42, -1, 1613 + -1, 45, 176, 177, -1, -1, 50, -1, -1, -1, 1614 + -1, -1, -1, -1, -1, 59, -1, 61, -1, -1, 1615 + -1, -1, -1, 67, 68, -1, 70, -1, -1, -1, 1616 + 74, 205, -1, 77, 208, -1, -1, -1, -1, -1, 1617 + 84, -1, -1, -1, -1, -1, -1, 91, -1, -1, 1618 + -1, 95, -1, 97, 98, 99, 100, 101, -1, -1, 1619 + -1, -1, -1, 107, -1, -1, -1, -1, 112, -1, 1614 1620 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1615 - 125, -1, -1, -1, -1, -1, -1, -1, 5, -1, 1616 - -1, -1, -1, -1, 139, -1, -1, -1, -1, 144, 1617 - 145, 146, -1, -1, 149, -1, 151, 152, -1, -1, 1618 - 155, -1, -1, -1, -1, 32, -1, 34, -1, 164, 1619 - -1, 166, 39, 40, -1, -1, -1, 44, -1, 174, 1620 - 175, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1621 - -1, -1, -1, 60, -1, -1, -1, 192, -1, 66, 1622 - 67, -1, 69, -1, 71, -1, 73, -1, 203, 76, 1623 - -1, -1, -1, -1, -1, -1, 83, -1, -1, -1, 1624 - -1, -1, -1, -1, -1, -1, -1, 94, -1, 96, 1625 - 97, 98, -1, -1, -1, -1, -1, -1, 105, -1, 1626 - -1, 5, -1, -1, -1, 14, 15, 16, 17, 18, 1627 - 19, 20, 21, 22, -1, -1, -1, -1, 125, 23, 1628 - -1, -1, -1, -1, -1, -1, -1, -1, 32, -1, 1629 - 34, -1, 139, -1, -1, -1, 40, 144, 145, 146, 1630 - 44, -1, 149, -1, 151, 152, -1, -1, 155, -1, 1631 - -1, -1, -1, -1, -1, -1, 60, 164, -1, 166, 1632 - -1, -1, 66, 67, -1, 69, -1, 174, 175, 73, 1633 - -1, -1, 76, -1, -1, 5, -1, -1, -1, 83, 1634 - -1, -1, -1, -1, -1, 192, -1, -1, -1, -1, 1635 - 94, -1, 96, 97, 98, -1, 203, -1, -1, -1, 1636 - -1, 105, 32, -1, 34, -1, -1, -1, -1, -1, 1637 - 40, -1, -1, -1, 44, 14, 15, 16, 17, 18, 1638 - 19, 20, 21, 22, -1, -1, -1, -1, -1, -1, 1639 - 60, -1, -1, -1, -1, 139, 66, 67, -1, 69, 1640 - 144, 145, 146, 73, -1, 149, 76, 151, -1, -1, 1641 - -1, 155, -1, 83, -1, -1, -1, -1, -1, -1, 1642 - 164, -1, 166, -1, 94, -1, 96, 97, 98, -1, 1643 - 174, 175, -1, -1, 183, 105, 185, 186, 187, 188, 1644 - 189, 190, 191, 192, 193, 194, -1, -1, -1, -1, 1645 - -1, -1, -1, 202, 203, -1, -1, -1, -1, 203, 1646 - 209, -1, 14, 15, 16, 17, 18, 19, 20, 139, 1647 - 22, -1, -1, -1, 144, 145, 146, -1, -1, 149, 1648 - -1, 151, -1, -1, -1, 155, -1, -1, -1, -1, 1649 - -1, -1, -1, -1, 164, -1, 166, -1, -1, -1, 1650 - -1, -1, -1, -1, 174, 175, 14, 15, 16, 17, 1651 - 18, 19, 20, 21, 22, -1, -1, -1, -1, -1, 1621 + -1, -1, -1, -1, -1, 129, -1, -1, -1, -1, 1622 + 4, 5, -1, -1, -1, -1, -1, 141, -1, 13, 1623 + -1, -1, 146, 147, 148, -1, -1, 151, -1, 153, 1624 + -1, -1, -1, 157, -1, -1, -1, -1, -1, 33, 1625 + 164, 35, 166, -1, 168, -1, -1, 41, 42, -1, 1626 + -1, 45, 176, 177, -1, -1, 50, -1, -1, -1, 1627 + -1, -1, -1, -1, -1, 59, -1, 61, -1, -1, 1628 + -1, -1, -1, 67, 68, -1, 70, -1, -1, -1, 1629 + 74, 205, -1, 77, -1, -1, -1, -1, -1, -1, 1630 + 84, -1, -1, -1, -1, -1, -1, 91, 92, -1, 1631 + -1, 95, -1, 97, 98, 99, 100, 101, 5, -1, 1632 + -1, -1, -1, 107, -1, -1, -1, -1, 112, -1, 1652 1633 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1653 - -1, -1, -1, 203, 14, 15, 16, 17, 18, 19, 1654 - 20, 21, 22, -1, 183, -1, 185, 186, 187, 188, 1655 - 189, 190, 191, 192, 193, 194, -1, -1, -1, -1, 1656 - -1, -1, -1, 202, 203, -1, -1, -1, -1, -1, 1657 - 209, 14, 15, 16, 17, 18, 19, 20, 21, 22, 1634 + -1, -1, -1, -1, -1, 129, 33, -1, 35, -1, 1635 + -1, -1, -1, 40, 41, -1, -1, 141, 45, -1, 1636 + -1, -1, 146, 147, 148, -1, -1, 151, -1, 153, 1637 + -1, -1, -1, 157, 61, -1, -1, -1, -1, -1, 1638 + 67, 68, 166, 70, 168, 72, -1, 74, -1, -1, 1639 + 77, -1, 176, 177, -1, -1, -1, 84, -1, -1, 1640 + -1, -1, -1, -1, -1, -1, 5, -1, 95, -1, 1641 + 97, 98, 99, 100, -1, -1, -1, -1, -1, -1, 1642 + 107, 205, -1, -1, -1, -1, -1, -1, -1, -1, 1643 + -1, -1, -1, -1, 33, -1, 35, -1, -1, -1, 1644 + 127, 40, 41, -1, -1, -1, 45, -1, -1, -1, 1645 + -1, -1, -1, -1, 141, -1, -1, -1, -1, 146, 1646 + 147, 148, 61, -1, 151, -1, 153, 154, 67, 68, 1647 + 157, 70, -1, 72, -1, 74, -1, -1, 77, 166, 1648 + -1, 168, -1, -1, -1, 84, -1, -1, -1, 176, 1649 + 177, -1, -1, -1, 5, -1, 95, -1, 97, 98, 1650 + 99, 100, -1, -1, -1, -1, -1, 194, 107, -1, 1651 + -1, -1, -1, 24, -1, -1, -1, -1, 205, -1, 1652 + -1, -1, 33, -1, 35, -1, -1, -1, 127, -1, 1653 + 41, -1, -1, -1, 45, -1, -1, -1, -1, -1, 1654 + -1, -1, 141, -1, -1, -1, -1, 146, 147, 148, 1655 + 61, -1, 151, -1, 153, 154, 67, 68, 157, 70, 1656 + -1, -1, -1, 74, -1, -1, 77, 166, -1, 168, 1657 + -1, -1, -1, 84, -1, -1, -1, 176, 177, -1, 1658 + -1, -1, 5, -1, 95, -1, 97, 98, 99, 100, 1659 + -1, -1, -1, -1, -1, 194, 107, 15, 16, 17, 1660 + 18, 19, 20, 21, 22, 23, 205, -1, -1, -1, 1661 + 33, -1, 35, -1, -1, -1, -1, -1, 41, -1, 1662 + -1, -1, 45, -1, -1, -1, -1, -1, -1, -1, 1663 + 141, -1, -1, -1, -1, 146, 147, 148, 61, -1, 1664 + 151, -1, 153, -1, 67, 68, 157, 70, -1, -1, 1665 + -1, 74, -1, -1, 77, 166, -1, 168, -1, -1, 1666 + -1, 84, -1, -1, -1, 176, 177, -1, -1, -1, 1667 + -1, -1, 95, -1, 97, 98, 99, 100, -1, -1, 1668 + -1, -1, -1, -1, 107, 15, 16, 17, 18, 19, 1669 + 20, 21, 22, 23, 205, -1, -1, -1, -1, -1, 1670 + -1, -1, -1, -1, -1, -1, -1, 15, 16, 17, 1671 + 18, 19, 20, 21, 22, 23, -1, -1, 141, -1, 1672 + -1, -1, -1, 146, 147, 148, -1, -1, 151, -1, 1673 + 153, -1, -1, -1, 157, -1, -1, -1, -1, -1, 1674 + -1, -1, -1, 166, -1, 168, -1, -1, -1, -1, 1675 + -1, -1, -1, 176, 177, 15, 16, 17, 18, 19, 1676 + 20, 21, 22, 23, -1, -1, -1, 185, -1, 187, 1677 + 188, 189, 190, 191, 192, 193, 194, 195, 196, -1, 1678 + -1, -1, 205, -1, -1, -1, 204, 205, -1, -1, 1679 + -1, -1, -1, 211, 15, 16, 17, 18, 19, 20, 1680 + 21, 22, 23, -1, -1, -1, -1, -1, -1, -1, 1681 + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, 1682 + -1, 23, -1, -1, -1, -1, -1, -1, -1, -1, 1683 + -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, 1658 1684 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1659 - -1, -1, 14, 15, 16, 17, 18, 19, 20, 21, 1660 - 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1661 - -1, 14, 15, 16, 17, 18, 19, 20, 14, 15, 1662 - 16, 17, 18, 19, 20, -1, -1, -1, -1, -1, 1663 - -1, -1, -1, 185, 186, 187, 188, 189, 190, 191, 1664 - 192, 193, 194, -1, -1, -1, -1, -1, -1, -1, 1665 - 202, 203, -1, -1, -1, -1, -1, -1, -1, -1, 1685 + -1, -1, -1, -1, -1, 185, -1, 187, 188, 189, 1686 + 190, 191, 192, 193, 194, 195, 196, 15, 16, 17, 1687 + 18, 19, 20, 21, 204, 205, 206, 185, -1, 187, 1688 + 188, 189, 190, 191, 192, 193, 194, 195, 196, 15, 1689 + 16, 17, 18, 19, 20, 21, 204, 205, 206, -1, 1666 1690 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1667 - -1, -1, -1, -1, -1, 183, -1, 185, 186, 187, 1668 - 188, 189, 190, 191, 192, 193, 194, -1, -1, -1, 1669 - -1, -1, -1, -1, 202, 203, 204, -1, -1, -1, 1670 - -1, -1, -1, 183, -1, 185, 186, 187, 188, 189, 1671 - 190, 191, 192, 193, 194, -1, -1, -1, -1, -1, 1672 - -1, -1, 202, 203, 204, -1, -1, -1, -1, -1, 1673 1691 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1674 - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1675 - 193, 194, -1, -1, -1, -1, -1, -1, -1, 202, 1676 - 203, 183, -1, 185, 186, 187, 188, 189, 190, 191, 1677 - 192, 193, 194, -1, 5, -1, -1, -1, -1, -1, 1678 - 202, 203, 185, 186, 187, 188, 189, 190, 191, 192, 1679 - 193, 194, 188, 189, 190, 191, 192, 193, 194, 202, 1680 - 203, 32, -1, 34, -1, -1, 202, 203, -1, 40, 1681 - 41, -1, -1, 44, -1, -1, -1, -1, -1, -1, 1682 - -1, -1, -1, -1, -1, -1, -1, 58, -1, 60, 1683 - -1, -1, -1, -1, -1, 66, 67, -1, 69, -1, 1684 - -1, -1, 73, -1, -1, 76, -1, -1, 5, -1, 1685 - -1, -1, 83, -1, -1, -1, -1, -1, -1, -1, 1686 - -1, -1, -1, 94, -1, 96, 97, 98, 99, -1, 1687 - -1, 102, -1, -1, 105, 32, -1, 34, 109, -1, 1688 - -1, -1, -1, 40, -1, -1, -1, 44, -1, -1, 1692 + -1, -1, -1, -1, -1, 185, 186, 187, 188, 189, 1693 + 190, 191, 192, 193, 194, 195, 196, -1, -1, -1, 1694 + -1, -1, -1, -1, 204, 205, -1, -1, -1, -1, 1689 1695 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1690 - -1, -1, -1, 60, -1, -1, -1, -1, 139, 66, 1691 - 67, -1, 69, 144, 145, 146, 73, -1, 149, 76, 1692 - 151, -1, 5, -1, 155, -1, 83, -1, -1, -1, 1693 - -1, -1, -1, 164, -1, 166, -1, 94, -1, 96, 1694 - 97, 98, -1, 174, 175, -1, -1, -1, 105, 32, 1695 - -1, 34, -1, -1, -1, -1, -1, 40, -1, -1, 1696 + -1, -1, -1, -1, 185, -1, 187, 188, 189, 190, 1697 + 191, 192, 193, 194, 195, 196, -1, -1, -1, -1, 1698 + -1, -1, -1, 204, 205, 187, 188, 189, 190, 191, 1699 + 192, 193, 194, 195, 196, -1, -1, -1, -1, -1, 1700 + -1, -1, 204, 205, 187, 188, 189, 190, 191, 192, 1701 + 193, 194, 195, 196, -1, -1, -1, -1, -1, -1, 1702 + -1, 204, 205, -1, -1, -1, -1, -1, -1, -1, 1696 1703 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1697 - -1, -1, -1, -1, -1, -1, -1, 60, -1, -1, 1698 - -1, -1, 139, 66, 67, -1, -1, 144, 145, 146, 1699 - 73, -1, 149, 76, 151, -1, -1, -1, 155, -1, 1700 - 83, -1, -1, -1, -1, -1, -1, 164, -1, 166, 1701 - -1, -1, -1, 96, 97, 98, -1, 174, 175, -1, 1702 - -1, -1, 105, -1, -1, -1, -1, -1, -1, -1, 1704 + 188, 189, 190, 191, 192, 193, 194, 195, 196, -1, 1705 + -1, -1, 5, -1, -1, -1, 204, 205, -1, -1, 1706 + -1, -1, -1, 189, 190, 191, 192, 193, 194, 195, 1707 + 196, -1, -1, -1, -1, -1, -1, -1, 204, 205, 1708 + 33, -1, 35, -1, -1, -1, -1, -1, 41, 42, 1709 + -1, -1, 45, -1, -1, -1, -1, 5, -1, -1, 1710 + -1, -1, -1, -1, -1, -1, 59, -1, 61, -1, 1711 + -1, -1, -1, -1, 67, 68, -1, 70, -1, -1, 1712 + -1, 74, -1, -1, 77, 33, -1, 35, -1, -1, 1713 + -1, 84, -1, 41, -1, -1, -1, 45, -1, -1, 1714 + -1, -1, 95, -1, 97, 98, 99, 100, 101, -1, 1715 + -1, 104, -1, 61, 107, -1, -1, -1, 111, 67, 1716 + 68, -1, 70, -1, -1, -1, 74, -1, -1, 77, 1717 + -1, -1, -1, -1, -1, -1, 84, -1, -1, -1, 1718 + -1, -1, -1, -1, -1, -1, -1, 95, 141, 97, 1719 + 98, 99, 100, 146, 147, 148, -1, -1, 151, 107, 1720 + 153, 5, -1, -1, 157, -1, -1, -1, -1, -1, 1721 + -1, -1, -1, 166, -1, 168, -1, -1, -1, -1, 1722 + -1, -1, -1, 176, 177, -1, -1, -1, -1, 33, 1723 + -1, 35, -1, 141, -1, -1, -1, 41, 146, 147, 1724 + 148, -1, -1, 151, -1, 153, -1, -1, -1, 157, 1725 + -1, -1, -1, -1, -1, -1, -1, 61, 166, -1, 1726 + 168, -1, -1, 67, 68, -1, -1, -1, 176, 177, 1727 + 74, -1, -1, 77, -1, -1, -1, -1, -1, -1, 1728 + 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1729 + -1, -1, -1, 97, 98, 99, 100, -1, -1, -1, 1730 + -1, -1, -1, 107, -1, -1, -1, -1, -1, -1, 1703 1731 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1704 1732 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1705 1733 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1706 - -1, 144, 145, 146, -1, -1, 149, -1, -1, -1, 1707 - -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, 1708 - -1, 164, -1, 166, -1, -1, -1, -1, -1, -1, 1709 - -1, 174, 175, 24, -1, 26, 27, 28, 29, 30, 1710 - 31, -1, 33, -1, -1, 36, -1, 38, -1, -1, 1711 - -1, 42, 43, -1, 45, 46, 47, 48, -1, 50, 1712 - 51, 52, 53, 54, 55, 56, 57, -1, 59, -1, 1713 - 61, 62, 63, 64, 65, -1, -1, 68, -1, -1, 1714 - -1, 72, -1, 74, 75, -1, 77, 78, 79, 80, 1715 - 81, 82, -1, 84, 85, 86, 87, 88, 89, -1, 1716 - -1, 92, -1, -1, 95, -1, -1, -1, -1, 100, 1717 - 101, -1, 103, 104, -1, 106, 107, -1, -1, -1, 1718 - 111, 112, 113, 114, 115, 116, -1, 118, 119, 120, 1719 - 121, 122, 123, 124, -1, 126, -1, 128, -1, 130, 1720 - 131, 132, 133, 134, 135, 136, 137, 138, -1, 140, 1721 - 141, 142, 143, -1, -1, -1, 147, -1, -1, 150, 1722 - -1, -1, 153, 154, -1, -1, 157, 158, 159, 160, 1723 - -1, -1, 163, -1, 165, -1, 167, 168, 169, 170, 1724 - 171, 172, 173, -1, -1, 176 1734 + -1, -1, 146, 147, 148, -1, -1, 151, -1, -1, 1735 + -1, -1, -1, 157, -1, -1, -1, -1, -1, -1, 1736 + -1, -1, 166, -1, 168, -1, -1, -1, -1, -1, 1737 + -1, -1, 176, 177, 25, -1, 27, 28, 29, 30, 1738 + 31, 32, -1, 34, -1, -1, 37, -1, 39, -1, 1739 + -1, -1, 43, 44, -1, 46, 47, 48, 49, -1, 1740 + 51, 52, 53, 54, 55, 56, 57, 58, -1, 60, 1741 + -1, 62, 63, 64, 65, 66, -1, -1, 69, -1, 1742 + -1, -1, 73, -1, 75, 76, -1, 78, 79, 80, 1743 + 81, 82, 83, -1, 85, 86, 87, 88, 89, 90, 1744 + -1, -1, 93, -1, -1, 96, -1, -1, -1, -1, 1745 + -1, 102, 103, -1, 105, 106, -1, 108, 109, -1, 1746 + -1, -1, 113, 114, 115, 116, 117, 118, -1, 120, 1747 + 121, 122, 123, 124, 125, 126, -1, 128, -1, 130, 1748 + -1, 132, 133, 134, 135, 136, 137, 138, 139, 140, 1749 + -1, 142, 143, 144, 145, -1, -1, -1, 149, -1, 1750 + -1, 152, -1, -1, 155, 156, -1, -1, 159, 160, 1751 + 161, 162, -1, -1, 165, -1, 167, -1, 169, 170, 1752 + 171, 172, 173, 174, 175, -1, -1, 178 1725 1753 }; 1726 1754 1727 1755 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1728 1756 symbol of state STATE-NUM. */ 1729 1757 static const yytype_uint16 yystos[] = 1730 1758 { 1731 - 0, 212, 213, 0, 4, 5, 32, 34, 40, 41, 1732 - 44, 49, 58, 60, 66, 67, 69, 73, 76, 83, 1733 - 90, 94, 96, 97, 98, 99, 105, 110, 127, 139, 1734 - 144, 145, 146, 149, 151, 155, 164, 166, 174, 175, 1735 - 203, 219, 220, 222, 223, 224, 225, 228, 229, 235, 1736 - 236, 247, 261, 265, 267, 268, 269, 270, 271, 274, 1737 - 275, 278, 280, 281, 282, 283, 285, 286, 287, 288, 1738 - 289, 291, 293, 311, 312, 313, 314, 3, 5, 208, 1739 - 3, 5, 3, 5, 263, 96, 266, 9, 3, 5, 1740 - 266, 3, 208, 208, 266, 267, 3, 263, 3, 263, 1741 - 267, 24, 26, 27, 28, 29, 30, 31, 33, 36, 1742 - 38, 42, 43, 45, 46, 47, 48, 50, 51, 52, 1743 - 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 1744 - 65, 68, 72, 74, 75, 77, 78, 79, 80, 81, 1745 - 82, 84, 85, 86, 87, 88, 89, 92, 95, 100, 1746 - 101, 103, 104, 106, 107, 111, 112, 113, 114, 115, 1747 - 116, 118, 119, 120, 121, 122, 123, 124, 126, 128, 1748 - 130, 131, 132, 133, 134, 135, 136, 137, 138, 140, 1749 - 141, 142, 143, 147, 150, 153, 154, 157, 158, 159, 1750 - 160, 163, 165, 167, 168, 169, 170, 171, 172, 173, 1751 - 176, 237, 239, 310, 207, 215, 215, 162, 66, 102, 1752 - 109, 155, 164, 227, 247, 268, 274, 280, 284, 291, 1753 - 311, 314, 207, 207, 205, 205, 207, 205, 207, 218, 1754 - 207, 184, 279, 205, 292, 293, 292, 292, 3, 5, 1755 - 39, 71, 125, 152, 192, 208, 241, 264, 294, 295, 1756 - 308, 247, 311, 312, 314, 292, 207, 9, 205, 207, 1757 - 3, 312, 205, 156, 205, 208, 208, 208, 208, 208, 1758 - 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 1759 - 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 1760 - 208, 208, 208, 208, 208, 208, 208, 208, 182, 204, 1761 - 13, 91, 219, 226, 229, 268, 270, 271, 282, 283, 1762 - 286, 206, 235, 236, 3, 3, 5, 3, 5, 3, 1763 - 3, 205, 308, 272, 214, 129, 276, 280, 3, 5, 1764 - 205, 217, 290, 294, 294, 210, 203, 208, 234, 292, 1765 - 209, 244, 245, 246, 264, 184, 209, 254, 208, 257, 1766 - 9, 9, 12, 240, 264, 3, 6, 7, 8, 9, 1767 - 10, 11, 70, 117, 148, 161, 187, 190, 191, 192, 1768 - 195, 196, 208, 250, 251, 252, 250, 253, 9, 9, 1769 - 238, 253, 252, 9, 9, 252, 9, 252, 250, 233, 1770 - 236, 291, 252, 248, 249, 250, 9, 310, 9, 252, 1771 - 312, 248, 250, 312, 177, 178, 179, 180, 181, 309, 1772 - 312, 312, 240, 6, 7, 315, 9, 312, 239, 203, 1773 - 208, 207, 205, 218, 291, 206, 235, 273, 213, 184, 1774 - 108, 235, 259, 277, 207, 205, 217, 206, 219, 236, 1775 - 289, 294, 209, 253, 192, 204, 250, 230, 231, 232, 1776 - 233, 206, 182, 210, 6, 221, 206, 235, 255, 259, 1777 - 206, 236, 256, 259, 209, 209, 209, 208, 250, 250, 1778 - 250, 250, 250, 250, 250, 291, 14, 15, 16, 17, 1779 - 18, 19, 20, 21, 22, 183, 185, 186, 187, 188, 1780 - 189, 190, 191, 192, 193, 194, 202, 203, 182, 209, 1781 - 209, 209, 182, 209, 209, 209, 209, 209, 209, 209, 1782 - 209, 209, 209, 291, 192, 208, 234, 241, 264, 300, 1783 - 302, 303, 209, 182, 209, 209, 209, 209, 182, 209, 1784 - 209, 209, 209, 209, 209, 209, 209, 202, 209, 209, 1785 - 209, 239, 9, 216, 294, 304, 218, 283, 206, 184, 1786 - 291, 311, 207, 206, 236, 260, 261, 206, 225, 206, 1787 - 218, 204, 204, 209, 182, 246, 252, 6, 209, 291, 1788 - 314, 209, 207, 207, 291, 209, 192, 208, 234, 241, 1789 - 296, 298, 299, 250, 250, 3, 250, 250, 250, 250, 1790 - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 1791 - 250, 250, 250, 3, 250, 252, 9, 302, 290, 192, 1792 - 230, 241, 301, 302, 208, 234, 249, 252, 6, 209, 1793 - 215, 182, 294, 207, 217, 218, 23, 233, 300, 306, 1794 - 307, 207, 262, 264, 298, 290, 192, 230, 241, 297, 1795 - 298, 209, 208, 234, 184, 204, 302, 290, 209, 302, 1796 - 209, 230, 209, 218, 206, 294, 206, 184, 305, 182, 1797 - 207, 205, 209, 298, 290, 209, 302, 209, 250, 230, 1798 - 250, 302, 209, 218, 253, 306, 242, 302, 209, 38, 1799 - 51, 206, 243, 252, 184, 184, 207, 258, 259, 258, 1800 - 207 1759 + 0, 214, 216, 0, 4, 5, 14, 33, 35, 41, 1760 + 42, 45, 50, 59, 61, 67, 68, 70, 74, 77, 1761 + 84, 91, 95, 97, 98, 99, 100, 101, 107, 112, 1762 + 129, 141, 146, 147, 148, 151, 153, 157, 166, 168, 1763 + 176, 177, 205, 215, 222, 223, 225, 226, 227, 228, 1764 + 231, 232, 238, 239, 250, 264, 268, 270, 271, 272, 1765 + 273, 274, 277, 278, 281, 283, 284, 285, 286, 288, 1766 + 289, 290, 291, 292, 294, 296, 314, 315, 316, 317, 1767 + 205, 319, 322, 323, 3, 5, 210, 3, 5, 3, 1768 + 5, 266, 97, 269, 9, 3, 5, 269, 3, 210, 1769 + 210, 269, 270, 3, 266, 3, 266, 270, 25, 27, 1770 + 28, 29, 30, 31, 32, 34, 37, 39, 43, 44, 1771 + 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 1772 + 57, 58, 60, 62, 63, 64, 65, 66, 69, 73, 1773 + 75, 76, 78, 79, 80, 81, 82, 83, 85, 86, 1774 + 87, 88, 89, 90, 93, 96, 102, 103, 105, 106, 1775 + 108, 109, 113, 114, 115, 116, 117, 118, 120, 121, 1776 + 122, 123, 124, 125, 126, 128, 130, 132, 133, 134, 1777 + 135, 136, 137, 138, 139, 140, 142, 143, 144, 145, 1778 + 149, 152, 155, 156, 159, 160, 161, 162, 165, 167, 1779 + 169, 170, 171, 172, 173, 174, 175, 178, 240, 242, 1780 + 313, 209, 218, 218, 164, 67, 104, 111, 157, 166, 1781 + 230, 250, 271, 277, 283, 287, 294, 314, 317, 209, 1782 + 209, 207, 207, 209, 207, 209, 221, 209, 186, 282, 1783 + 207, 295, 296, 295, 295, 3, 5, 40, 72, 127, 1784 + 154, 194, 210, 244, 267, 297, 298, 311, 250, 314, 1785 + 315, 317, 295, 209, 51, 64, 69, 324, 325, 319, 1786 + 101, 9, 207, 209, 3, 315, 207, 158, 207, 210, 1787 + 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, 1788 + 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, 1789 + 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, 1790 + 210, 210, 184, 206, 13, 92, 222, 229, 232, 271, 1791 + 273, 274, 285, 286, 289, 208, 238, 239, 3, 3, 1792 + 5, 3, 5, 3, 3, 207, 311, 275, 217, 131, 1793 + 279, 283, 3, 5, 207, 220, 293, 297, 297, 212, 1794 + 205, 210, 237, 295, 184, 206, 5, 211, 247, 248, 1795 + 249, 267, 186, 211, 257, 210, 260, 9, 9, 12, 1796 + 243, 267, 3, 6, 7, 8, 9, 10, 11, 71, 1797 + 119, 150, 163, 189, 192, 193, 194, 197, 198, 210, 1798 + 253, 254, 255, 253, 256, 9, 9, 241, 256, 255, 1799 + 9, 9, 255, 9, 255, 253, 236, 239, 294, 255, 1800 + 251, 252, 253, 9, 313, 9, 255, 315, 251, 253, 1801 + 315, 179, 180, 181, 182, 183, 312, 315, 315, 243, 1802 + 6, 7, 318, 9, 315, 242, 205, 210, 209, 207, 1803 + 221, 294, 208, 238, 276, 216, 186, 110, 238, 262, 1804 + 280, 209, 207, 220, 208, 222, 239, 292, 297, 211, 1805 + 256, 194, 206, 253, 233, 234, 235, 236, 325, 207, 1806 + 208, 184, 212, 6, 224, 208, 238, 258, 262, 208, 1807 + 239, 259, 262, 211, 211, 211, 210, 253, 253, 253, 1808 + 253, 253, 253, 253, 294, 15, 16, 17, 18, 19, 1809 + 20, 21, 22, 23, 185, 187, 188, 189, 190, 191, 1810 + 192, 193, 194, 195, 196, 204, 205, 184, 211, 211, 1811 + 211, 184, 211, 211, 211, 211, 211, 211, 211, 211, 1812 + 211, 211, 294, 194, 210, 237, 244, 267, 303, 305, 1813 + 306, 211, 184, 211, 211, 211, 211, 184, 211, 211, 1814 + 211, 211, 211, 211, 211, 211, 204, 211, 211, 211, 1815 + 242, 9, 219, 297, 307, 221, 286, 208, 186, 294, 1816 + 314, 209, 208, 239, 263, 264, 208, 228, 208, 221, 1817 + 206, 206, 211, 184, 164, 320, 321, 249, 255, 6, 1818 + 211, 294, 317, 211, 209, 209, 294, 211, 194, 210, 1819 + 237, 244, 299, 301, 302, 253, 253, 3, 253, 253, 1820 + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 1821 + 253, 253, 253, 253, 253, 3, 253, 255, 9, 305, 1822 + 293, 194, 233, 244, 304, 305, 210, 237, 252, 255, 1823 + 6, 211, 218, 184, 297, 209, 220, 221, 24, 236, 1824 + 323, 208, 320, 303, 309, 310, 209, 265, 267, 301, 1825 + 293, 194, 233, 244, 300, 301, 211, 210, 237, 186, 1826 + 206, 305, 293, 211, 305, 211, 233, 211, 221, 208, 1827 + 297, 208, 5, 186, 308, 184, 209, 207, 211, 301, 1828 + 293, 211, 305, 211, 253, 233, 253, 305, 211, 221, 1829 + 209, 256, 309, 245, 305, 211, 39, 52, 208, 246, 1830 + 255, 186, 186, 209, 261, 262, 261, 209 1801 1831 }; 1802 1832 1803 1833 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1804 1834 static const yytype_uint16 yyr1[] = 1805 1835 { 1806 - 0, 211, 212, 213, 214, 213, 213, 213, 213, 213, 1807 - 213, 213, 213, 215, 215, 216, 215, 215, 215, 215, 1808 - 215, 215, 215, 215, 217, 217, 218, 218, 219, 219, 1809 - 219, 219, 219, 219, 219, 220, 221, 221, 222, 222, 1810 - 222, 222, 222, 222, 222, 222, 222, 223, 224, 225, 1811 - 226, 227, 227, 228, 229, 230, 230, 231, 231, 232, 1812 - 232, 233, 233, 234, 234, 234, 235, 235, 236, 237, 1813 - 237, 237, 238, 238, 239, 239, 239, 239, 239, 239, 1814 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1815 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1816 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1817 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1818 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1819 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1820 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1821 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1822 - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 1823 - 239, 239, 239, 239, 240, 240, 241, 241, 241, 241, 1824 - 242, 242, 243, 243, 244, 244, 244, 245, 245, 246, 1825 - 246, 247, 248, 248, 249, 249, 250, 250, 250, 250, 1826 - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 1827 - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 1828 - 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 1829 - 250, 250, 250, 250, 250, 250, 250, 251, 251, 252, 1830 - 253, 254, 254, 255, 255, 256, 256, 257, 257, 258, 1831 - 258, 259, 259, 260, 261, 261, 262, 262, 263, 263, 1832 - 263, 264, 264, 265, 265, 265, 265, 265, 265, 265, 1833 - 265, 265, 265, 265, 266, 266, 267, 267, 267, 267, 1834 - 267, 267, 267, 267, 268, 268, 269, 270, 271, 272, 1835 - 272, 273, 274, 274, 275, 276, 276, 277, 277, 278, 1836 - 278, 279, 279, 280, 280, 281, 282, 282, 282, 283, 1837 - 283, 284, 284, 285, 286, 287, 287, 287, 288, 289, 1838 - 290, 290, 291, 291, 292, 292, 293, 293, 293, 294, 1839 - 294, 294, 295, 295, 295, 295, 296, 296, 296, 297, 1840 - 297, 298, 298, 299, 299, 299, 299, 299, 300, 300, 1841 - 300, 301, 301, 302, 302, 303, 303, 303, 303, 303, 1842 - 303, 304, 304, 305, 305, 306, 307, 307, 308, 308, 1843 - 309, 309, 309, 309, 309, 310, 310, 310, 311, 312, 1844 - 312, 312, 312, 312, 312, 312, 312, 312, 312, 313, 1845 - 314, 314, 315, 315, 315 1836 + 0, 213, 214, 215, 215, 216, 217, 216, 216, 216, 1837 + 216, 216, 216, 216, 216, 218, 218, 219, 218, 218, 1838 + 218, 218, 218, 218, 218, 218, 220, 220, 221, 221, 1839 + 222, 222, 222, 222, 222, 222, 222, 223, 224, 224, 1840 + 225, 225, 225, 225, 225, 225, 225, 225, 225, 226, 1841 + 227, 228, 229, 230, 230, 231, 232, 233, 233, 234, 1842 + 234, 235, 235, 236, 236, 237, 237, 237, 238, 238, 1843 + 239, 240, 240, 240, 241, 241, 242, 242, 242, 242, 1844 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1845 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1846 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1847 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1848 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1849 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1850 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1851 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1852 + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 1853 + 242, 242, 242, 242, 242, 242, 243, 243, 244, 244, 1854 + 244, 244, 245, 245, 246, 246, 247, 247, 247, 248, 1855 + 248, 249, 249, 250, 251, 251, 252, 252, 253, 253, 1856 + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 1857 + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 1858 + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 1859 + 253, 253, 253, 253, 253, 253, 253, 253, 253, 254, 1860 + 254, 255, 256, 257, 257, 258, 258, 259, 259, 260, 1861 + 260, 261, 261, 262, 262, 263, 264, 264, 265, 265, 1862 + 266, 266, 266, 267, 267, 268, 268, 268, 268, 268, 1863 + 268, 268, 268, 268, 268, 268, 269, 269, 270, 270, 1864 + 270, 270, 270, 270, 270, 270, 270, 271, 271, 272, 1865 + 273, 274, 275, 275, 276, 277, 277, 278, 279, 279, 1866 + 280, 280, 281, 281, 282, 282, 283, 283, 284, 285, 1867 + 285, 285, 286, 286, 287, 287, 288, 289, 290, 290, 1868 + 290, 291, 292, 293, 293, 294, 294, 295, 295, 296, 1869 + 296, 296, 297, 297, 297, 298, 298, 298, 298, 299, 1870 + 299, 299, 300, 300, 301, 301, 302, 302, 302, 302, 1871 + 302, 303, 303, 303, 304, 304, 305, 305, 306, 306, 1872 + 306, 306, 306, 306, 307, 307, 308, 308, 309, 310, 1873 + 310, 311, 311, 312, 312, 312, 312, 312, 313, 313, 1874 + 313, 314, 315, 315, 315, 315, 315, 315, 315, 315, 1875 + 315, 315, 316, 317, 317, 318, 318, 318, 319, 319, 1876 + 320, 320, 321, 322, 323, 323, 324, 324, 325, 325, 1877 + 325 1846 1878 }; 1847 1879 1848 1880 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 1849 1881 static const yytype_uint8 yyr2[] = 1850 1882 { 1851 - 0, 2, 1, 0, 0, 6, 2, 2, 3, 2, 1852 - 2, 2, 2, 0, 2, 0, 6, 2, 3, 2, 1853 - 2, 2, 2, 2, 0, 2, 0, 1, 1, 2, 1854 - 2, 1, 2, 1, 1, 6, 1, 2, 1, 2, 1855 - 1, 2, 1, 2, 2, 2, 2, 4, 3, 3, 1856 - 5, 2, 2, 3, 4, 0, 1, 1, 3, 1, 1857 - 3, 3, 2, 3, 3, 2, 0, 1, 3, 1, 1858 - 3, 4, 1, 3, 0, 1, 4, 1, 1, 1, 1859 - 1, 1, 4, 4, 1, 1, 1, 1, 1, 1, 1860 - 1, 1, 1, 1, 4, 1, 1, 1, 4, 1, 1861 - 1, 1, 4, 4, 1, 1, 1, 1, 4, 4, 1862 - 4, 4, 4, 1, 4, 1, 1, 4, 1, 4, 1863 - 1, 1, 4, 4, 1, 1, 1, 1, 1, 1, 1864 - 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1865 - 1, 1, 4, 4, 1, 1, 1, 1, 1, 6, 1866 - 1, 4, 1, 1, 1, 4, 1, 1, 1, 4, 1867 - 4, 4, 4, 1, 1, 4, 4, 4, 1, 1, 1868 - 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1869 - 0, 2, 4, 3, 0, 2, 1, 1, 3, 3, 1870 - 1, 5, 1, 3, 0, 1, 1, 1, 1, 1, 1871 - 1, 1, 1, 1, 1, 1, 5, 3, 3, 3, 1883 + 0, 2, 2, 0, 2, 0, 0, 6, 2, 2, 1884 + 3, 2, 2, 2, 2, 0, 2, 0, 6, 2, 1885 + 3, 2, 2, 2, 2, 2, 0, 2, 0, 1, 1886 + 1, 2, 2, 1, 2, 1, 1, 6, 1, 2, 1887 + 1, 2, 1, 2, 1, 2, 2, 2, 2, 4, 1888 + 3, 3, 5, 2, 2, 3, 4, 0, 1, 1, 1889 + 3, 1, 3, 3, 2, 3, 3, 2, 0, 1, 1890 + 3, 1, 3, 4, 1, 3, 0, 1, 4, 1, 1891 + 1, 1, 1, 1, 4, 4, 1, 1, 1, 1, 1892 + 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1893 + 4, 1, 1, 1, 4, 4, 1, 1, 1, 1, 1894 + 4, 4, 4, 4, 4, 1, 4, 1, 1, 4, 1895 + 1, 4, 1, 1, 4, 4, 1, 1, 1, 1, 1896 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1897 + 4, 1, 1, 1, 4, 4, 1, 1, 1, 1, 1898 + 1, 6, 1, 4, 1, 1, 1, 4, 1, 1, 1899 + 1, 4, 4, 4, 4, 1, 1, 4, 4, 4, 1900 + 1, 1, 4, 4, 4, 1, 1, 1, 1, 1, 1901 + 1, 1, 0, 2, 4, 3, 0, 2, 1, 1, 1902 + 3, 3, 1, 5, 1, 3, 0, 1, 1, 1, 1903 + 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 1872 1904 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1873 - 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1874 - 2, 3, 3, 5, 5, 4, 3, 1, 3, 1, 1875 - 1, 0, 2, 4, 3, 2, 2, 0, 2, 2, 1876 - 1, 3, 2, 1, 3, 2, 0, 1, 0, 1, 1877 - 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1878 - 1, 1, 1, 1, 0, 1, 1, 2, 1, 2, 1879 - 2, 1, 1, 1, 2, 2, 2, 5, 2, 0, 1880 - 2, 2, 2, 2, 2, 2, 3, 2, 3, 5, 1881 - 5, 0, 2, 2, 2, 2, 6, 8, 2, 2, 1882 - 2, 2, 2, 2, 5, 1, 1, 1, 1, 1, 1883 - 0, 2, 2, 3, 0, 1, 2, 2, 2, 3, 1884 - 2, 1, 1, 3, 2, 4, 3, 2, 1, 3, 1885 - 2, 0, 1, 3, 2, 1, 3, 4, 3, 2, 1886 - 1, 3, 2, 0, 1, 1, 3, 2, 1, 3, 1887 - 4, 1, 3, 0, 2, 2, 1, 3, 1, 3, 1888 - 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1889 - 1, 1, 1, 2, 1, 2, 1, 2, 4, 5, 1890 - 5, 10, 1, 3, 1 1905 + 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 1906 + 2, 2, 2, 3, 3, 5, 5, 4, 3, 1, 1907 + 3, 1, 1, 0, 2, 4, 3, 2, 2, 0, 1908 + 2, 2, 1, 3, 2, 1, 3, 2, 0, 1, 1909 + 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1910 + 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, 1911 + 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 1912 + 5, 2, 0, 2, 2, 2, 2, 2, 2, 3, 1913 + 2, 3, 5, 5, 0, 2, 2, 2, 2, 6, 1914 + 8, 2, 2, 2, 2, 2, 2, 5, 1, 1, 1915 + 1, 1, 1, 0, 2, 2, 3, 0, 1, 2, 1916 + 2, 2, 3, 2, 1, 1, 3, 2, 4, 3, 1917 + 2, 1, 3, 2, 0, 1, 3, 2, 1, 3, 1918 + 4, 3, 2, 1, 3, 2, 0, 1, 1, 3, 1919 + 2, 1, 3, 4, 1, 3, 0, 2, 2, 1, 1920 + 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1921 + 1, 5, 1, 1, 1, 1, 2, 1, 2, 1, 1922 + 2, 4, 5, 5, 10, 1, 3, 1, 0, 2, 1923 + 0, 2, 4, 6, 0, 3, 1, 3, 1, 1, 1924 + 1 1891 1925 }; 1892 1926 1893 1927 ··· 2564 2598 switch (yyn) 2565 2599 { 2566 2600 case 2: 2567 - #line 321 "parser.y" /* yacc.c:1646 */ 2601 + #line 327 "parser.y" /* yacc.c:1646 */ 2568 2602 { fix_incomplete(); 2569 - check_statements((yyvsp[0].stmt_list), FALSE); 2570 - check_all_user_types((yyvsp[0].stmt_list)); 2571 - write_header((yyvsp[0].stmt_list)); 2572 - write_id_data((yyvsp[0].stmt_list)); 2573 - write_proxies((yyvsp[0].stmt_list)); 2574 - write_client((yyvsp[0].stmt_list)); 2575 - write_server((yyvsp[0].stmt_list)); 2576 - write_regscript((yyvsp[0].stmt_list)); 2577 - write_dlldata((yyvsp[0].stmt_list)); 2578 - write_local_stubs((yyvsp[0].stmt_list)); 2603 + check_statements((yyvsp[-1].stmt_list), FALSE); 2604 + check_all_user_types((yyvsp[-1].stmt_list)); 2605 + write_header((yyvsp[-1].stmt_list)); 2606 + write_id_data((yyvsp[-1].stmt_list)); 2607 + write_proxies((yyvsp[-1].stmt_list)); 2608 + write_client((yyvsp[-1].stmt_list)); 2609 + write_server((yyvsp[-1].stmt_list)); 2610 + write_regscript((yyvsp[-1].stmt_list)); 2611 + #ifndef __REACTOS__ 2612 + write_typelib_regscript((yyvsp[-1].stmt_list)); 2613 + #endif 2614 + write_dlldata((yyvsp[-1].stmt_list)); 2615 + write_local_stubs((yyvsp[-1].stmt_list)); 2579 2616 } 2580 - #line 2581 "parser.tab.c" /* yacc.c:1646 */ 2617 + #line 2618 "parser.tab.c" /* yacc.c:1646 */ 2581 2618 break; 2582 2619 2583 - case 3: 2584 - #line 335 "parser.y" /* yacc.c:1646 */ 2620 + case 5: 2621 + #line 346 "parser.y" /* yacc.c:1646 */ 2585 2622 { (yyval.stmt_list) = NULL; } 2586 - #line 2587 "parser.tab.c" /* yacc.c:1646 */ 2623 + #line 2624 "parser.tab.c" /* yacc.c:1646 */ 2587 2624 break; 2588 2625 2589 - case 4: 2590 - #line 336 "parser.y" /* yacc.c:1646 */ 2626 + case 6: 2627 + #line 347 "parser.y" /* yacc.c:1646 */ 2591 2628 { push_namespace((yyvsp[-1].str)); } 2592 - #line 2593 "parser.tab.c" /* yacc.c:1646 */ 2629 + #line 2630 "parser.tab.c" /* yacc.c:1646 */ 2593 2630 break; 2594 2631 2595 - case 5: 2596 - #line 337 "parser.y" /* yacc.c:1646 */ 2632 + case 7: 2633 + #line 348 "parser.y" /* yacc.c:1646 */ 2597 2634 { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); } 2598 - #line 2599 "parser.tab.c" /* yacc.c:1646 */ 2635 + #line 2636 "parser.tab.c" /* yacc.c:1646 */ 2599 2636 break; 2600 2637 2601 - case 6: 2602 - #line 338 "parser.y" /* yacc.c:1646 */ 2638 + case 8: 2639 + #line 349 "parser.y" /* yacc.c:1646 */ 2603 2640 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); } 2604 - #line 2605 "parser.tab.c" /* yacc.c:1646 */ 2641 + #line 2642 "parser.tab.c" /* yacc.c:1646 */ 2605 2642 break; 2606 2643 2607 - case 7: 2608 - #line 339 "parser.y" /* yacc.c:1646 */ 2644 + case 9: 2645 + #line 350 "parser.y" /* yacc.c:1646 */ 2609 2646 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); } 2610 - #line 2611 "parser.tab.c" /* yacc.c:1646 */ 2647 + #line 2648 "parser.tab.c" /* yacc.c:1646 */ 2611 2648 break; 2612 2649 2613 - case 8: 2614 - #line 340 "parser.y" /* yacc.c:1646 */ 2650 + case 10: 2651 + #line 351 "parser.y" /* yacc.c:1646 */ 2615 2652 { (yyval.stmt_list) = (yyvsp[-2].stmt_list); 2616 2653 reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); 2617 2654 } 2618 - #line 2619 "parser.tab.c" /* yacc.c:1646 */ 2655 + #line 2656 "parser.tab.c" /* yacc.c:1646 */ 2619 2656 break; 2620 2657 2621 - case 9: 2622 - #line 343 "parser.y" /* yacc.c:1646 */ 2658 + case 11: 2659 + #line 354 "parser.y" /* yacc.c:1646 */ 2623 2660 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); 2624 2661 reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0); 2625 2662 } 2626 - #line 2627 "parser.tab.c" /* yacc.c:1646 */ 2663 + #line 2664 "parser.tab.c" /* yacc.c:1646 */ 2627 2664 break; 2628 2665 2629 - case 10: 2630 - #line 346 "parser.y" /* yacc.c:1646 */ 2666 + case 12: 2667 + #line 357 "parser.y" /* yacc.c:1646 */ 2631 2668 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); } 2632 - #line 2633 "parser.tab.c" /* yacc.c:1646 */ 2669 + #line 2670 "parser.tab.c" /* yacc.c:1646 */ 2633 2670 break; 2634 2671 2635 - case 11: 2636 - #line 347 "parser.y" /* yacc.c:1646 */ 2672 + case 13: 2673 + #line 358 "parser.y" /* yacc.c:1646 */ 2637 2674 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); } 2638 - #line 2639 "parser.tab.c" /* yacc.c:1646 */ 2675 + #line 2676 "parser.tab.c" /* yacc.c:1646 */ 2639 2676 break; 2640 2677 2641 - case 12: 2642 - #line 348 "parser.y" /* yacc.c:1646 */ 2678 + case 14: 2679 + #line 359 "parser.y" /* yacc.c:1646 */ 2643 2680 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } 2644 - #line 2645 "parser.tab.c" /* yacc.c:1646 */ 2681 + #line 2682 "parser.tab.c" /* yacc.c:1646 */ 2645 2682 break; 2646 2683 2647 - case 13: 2648 - #line 351 "parser.y" /* yacc.c:1646 */ 2684 + case 15: 2685 + #line 362 "parser.y" /* yacc.c:1646 */ 2649 2686 { (yyval.stmt_list) = NULL; } 2650 - #line 2651 "parser.tab.c" /* yacc.c:1646 */ 2687 + #line 2688 "parser.tab.c" /* yacc.c:1646 */ 2651 2688 break; 2652 2689 2653 - case 14: 2654 - #line 352 "parser.y" /* yacc.c:1646 */ 2690 + case 16: 2691 + #line 363 "parser.y" /* yacc.c:1646 */ 2655 2692 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); } 2656 - #line 2657 "parser.tab.c" /* yacc.c:1646 */ 2693 + #line 2694 "parser.tab.c" /* yacc.c:1646 */ 2657 2694 break; 2658 2695 2659 - case 15: 2660 - #line 353 "parser.y" /* yacc.c:1646 */ 2696 + case 17: 2697 + #line 364 "parser.y" /* yacc.c:1646 */ 2661 2698 { push_namespace((yyvsp[-1].str)); } 2662 - #line 2663 "parser.tab.c" /* yacc.c:1646 */ 2699 + #line 2700 "parser.tab.c" /* yacc.c:1646 */ 2663 2700 break; 2664 2701 2665 - case 16: 2666 - #line 354 "parser.y" /* yacc.c:1646 */ 2702 + case 18: 2703 + #line 365 "parser.y" /* yacc.c:1646 */ 2667 2704 { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); } 2668 - #line 2669 "parser.tab.c" /* yacc.c:1646 */ 2705 + #line 2706 "parser.tab.c" /* yacc.c:1646 */ 2669 2706 break; 2670 2707 2671 - case 17: 2672 - #line 355 "parser.y" /* yacc.c:1646 */ 2708 + case 19: 2709 + #line 366 "parser.y" /* yacc.c:1646 */ 2673 2710 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); } 2674 - #line 2675 "parser.tab.c" /* yacc.c:1646 */ 2711 + #line 2712 "parser.tab.c" /* yacc.c:1646 */ 2675 2712 break; 2676 2713 2677 - case 18: 2678 - #line 356 "parser.y" /* yacc.c:1646 */ 2714 + case 20: 2715 + #line 367 "parser.y" /* yacc.c:1646 */ 2679 2716 { (yyval.stmt_list) = (yyvsp[-2].stmt_list); reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); } 2680 - #line 2681 "parser.tab.c" /* yacc.c:1646 */ 2717 + #line 2718 "parser.tab.c" /* yacc.c:1646 */ 2681 2718 break; 2682 2719 2683 - case 19: 2684 - #line 357 "parser.y" /* yacc.c:1646 */ 2720 + case 21: 2721 + #line 368 "parser.y" /* yacc.c:1646 */ 2685 2722 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); 2686 2723 reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0); 2687 2724 } 2688 - #line 2689 "parser.tab.c" /* yacc.c:1646 */ 2725 + #line 2726 "parser.tab.c" /* yacc.c:1646 */ 2689 2726 break; 2690 2727 2691 - case 20: 2692 - #line 360 "parser.y" /* yacc.c:1646 */ 2728 + case 22: 2729 + #line 371 "parser.y" /* yacc.c:1646 */ 2693 2730 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); } 2694 - #line 2695 "parser.tab.c" /* yacc.c:1646 */ 2731 + #line 2732 "parser.tab.c" /* yacc.c:1646 */ 2695 2732 break; 2696 2733 2697 - case 21: 2698 - #line 361 "parser.y" /* yacc.c:1646 */ 2734 + case 23: 2735 + #line 372 "parser.y" /* yacc.c:1646 */ 2699 2736 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } 2700 - #line 2701 "parser.tab.c" /* yacc.c:1646 */ 2737 + #line 2738 "parser.tab.c" /* yacc.c:1646 */ 2701 2738 break; 2702 2739 2703 - case 22: 2704 - #line 362 "parser.y" /* yacc.c:1646 */ 2740 + case 24: 2741 + #line 373 "parser.y" /* yacc.c:1646 */ 2705 2742 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_importlib((yyvsp[0].str))); } 2706 - #line 2707 "parser.tab.c" /* yacc.c:1646 */ 2743 + #line 2744 "parser.tab.c" /* yacc.c:1646 */ 2707 2744 break; 2708 2745 2709 - case 23: 2710 - #line 363 "parser.y" /* yacc.c:1646 */ 2746 + case 25: 2747 + #line 374 "parser.y" /* yacc.c:1646 */ 2711 2748 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); } 2712 - #line 2713 "parser.tab.c" /* yacc.c:1646 */ 2749 + #line 2750 "parser.tab.c" /* yacc.c:1646 */ 2713 2750 break; 2714 2751 2715 - case 24: 2716 - #line 366 "parser.y" /* yacc.c:1646 */ 2752 + case 26: 2753 + #line 377 "parser.y" /* yacc.c:1646 */ 2717 2754 { (yyval.stmt_list) = NULL; } 2718 - #line 2719 "parser.tab.c" /* yacc.c:1646 */ 2755 + #line 2756 "parser.tab.c" /* yacc.c:1646 */ 2719 2756 break; 2720 2757 2721 - case 25: 2722 - #line 367 "parser.y" /* yacc.c:1646 */ 2758 + case 27: 2759 + #line 378 "parser.y" /* yacc.c:1646 */ 2723 2760 { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); } 2724 - #line 2725 "parser.tab.c" /* yacc.c:1646 */ 2761 + #line 2762 "parser.tab.c" /* yacc.c:1646 */ 2725 2762 break; 2726 2763 2727 - case 28: 2728 - #line 375 "parser.y" /* yacc.c:1646 */ 2764 + case 30: 2765 + #line 386 "parser.y" /* yacc.c:1646 */ 2729 2766 { (yyval.statement) = make_statement_cppquote((yyvsp[0].str)); } 2730 - #line 2731 "parser.tab.c" /* yacc.c:1646 */ 2767 + #line 2768 "parser.tab.c" /* yacc.c:1646 */ 2731 2768 break; 2732 2769 2733 - case 29: 2734 - #line 376 "parser.y" /* yacc.c:1646 */ 2770 + case 31: 2771 + #line 387 "parser.y" /* yacc.c:1646 */ 2735 2772 { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type)); } 2736 - #line 2737 "parser.tab.c" /* yacc.c:1646 */ 2773 + #line 2774 "parser.tab.c" /* yacc.c:1646 */ 2737 2774 break; 2738 2775 2739 - case 30: 2740 - #line 377 "parser.y" /* yacc.c:1646 */ 2776 + case 32: 2777 + #line 388 "parser.y" /* yacc.c:1646 */ 2741 2778 { (yyval.statement) = make_statement_declaration((yyvsp[-1].var)); } 2742 - #line 2743 "parser.tab.c" /* yacc.c:1646 */ 2779 + #line 2780 "parser.tab.c" /* yacc.c:1646 */ 2743 2780 break; 2744 2781 2745 - case 31: 2746 - #line 378 "parser.y" /* yacc.c:1646 */ 2782 + case 33: 2783 + #line 389 "parser.y" /* yacc.c:1646 */ 2747 2784 { (yyval.statement) = make_statement_import((yyvsp[0].str)); } 2748 - #line 2749 "parser.tab.c" /* yacc.c:1646 */ 2785 + #line 2786 "parser.tab.c" /* yacc.c:1646 */ 2749 2786 break; 2750 2787 2751 - case 32: 2752 - #line 379 "parser.y" /* yacc.c:1646 */ 2788 + case 34: 2789 + #line 390 "parser.y" /* yacc.c:1646 */ 2753 2790 { (yyval.statement) = (yyvsp[-1].statement); } 2754 - #line 2755 "parser.tab.c" /* yacc.c:1646 */ 2791 + #line 2792 "parser.tab.c" /* yacc.c:1646 */ 2755 2792 break; 2756 2793 2757 - case 33: 2758 - #line 380 "parser.y" /* yacc.c:1646 */ 2794 + case 35: 2795 + #line 391 "parser.y" /* yacc.c:1646 */ 2759 2796 { (yyval.statement) = make_statement_pragma((yyvsp[0].str)); } 2760 - #line 2761 "parser.tab.c" /* yacc.c:1646 */ 2797 + #line 2798 "parser.tab.c" /* yacc.c:1646 */ 2761 2798 break; 2762 2799 2763 - case 34: 2764 - #line 381 "parser.y" /* yacc.c:1646 */ 2800 + case 36: 2801 + #line 392 "parser.y" /* yacc.c:1646 */ 2765 2802 { (yyval.statement) = NULL; } 2766 - #line 2767 "parser.tab.c" /* yacc.c:1646 */ 2803 + #line 2804 "parser.tab.c" /* yacc.c:1646 */ 2767 2804 break; 2768 2805 2769 - case 35: 2770 - #line 385 "parser.y" /* yacc.c:1646 */ 2806 + case 37: 2807 + #line 396 "parser.y" /* yacc.c:1646 */ 2771 2808 { 2772 2809 int result; 2773 2810 (yyval.statement) = NULL; ··· 2775 2812 if(!result) 2776 2813 error_loc("expected \"disable\" or \"enable\"\n"); 2777 2814 } 2778 - #line 2779 "parser.tab.c" /* yacc.c:1646 */ 2815 + #line 2816 "parser.tab.c" /* yacc.c:1646 */ 2779 2816 break; 2780 2817 2781 - case 36: 2782 - #line 395 "parser.y" /* yacc.c:1646 */ 2818 + case 38: 2819 + #line 406 "parser.y" /* yacc.c:1646 */ 2783 2820 { (yyval.warning_list) = append_warning(NULL, (yyvsp[0].num)); } 2784 - #line 2785 "parser.tab.c" /* yacc.c:1646 */ 2821 + #line 2822 "parser.tab.c" /* yacc.c:1646 */ 2785 2822 break; 2786 2823 2787 - case 37: 2788 - #line 396 "parser.y" /* yacc.c:1646 */ 2824 + case 39: 2825 + #line 407 "parser.y" /* yacc.c:1646 */ 2789 2826 { (yyval.warning_list) = append_warning((yyvsp[-1].warning_list), (yyvsp[0].num)); } 2790 - #line 2791 "parser.tab.c" /* yacc.c:1646 */ 2827 + #line 2828 "parser.tab.c" /* yacc.c:1646 */ 2791 2828 break; 2792 2829 2793 - case 39: 2794 - #line 401 "parser.y" /* yacc.c:1646 */ 2830 + case 41: 2831 + #line 412 "parser.y" /* yacc.c:1646 */ 2795 2832 { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); } 2796 - #line 2797 "parser.tab.c" /* yacc.c:1646 */ 2833 + #line 2834 "parser.tab.c" /* yacc.c:1646 */ 2797 2834 break; 2798 2835 2799 - case 41: 2800 - #line 403 "parser.y" /* yacc.c:1646 */ 2836 + case 43: 2837 + #line 414 "parser.y" /* yacc.c:1646 */ 2801 2838 { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); } 2802 - #line 2803 "parser.tab.c" /* yacc.c:1646 */ 2839 + #line 2840 "parser.tab.c" /* yacc.c:1646 */ 2803 2840 break; 2804 2841 2805 - case 43: 2806 - #line 405 "parser.y" /* yacc.c:1646 */ 2842 + case 45: 2843 + #line 416 "parser.y" /* yacc.c:1646 */ 2807 2844 { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); } 2808 - #line 2809 "parser.tab.c" /* yacc.c:1646 */ 2845 + #line 2846 "parser.tab.c" /* yacc.c:1646 */ 2809 2846 break; 2810 2847 2811 - case 44: 2812 - #line 406 "parser.y" /* yacc.c:1646 */ 2848 + case 46: 2849 + #line 417 "parser.y" /* yacc.c:1646 */ 2813 2850 { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[-1].attr_list)); } 2814 - #line 2815 "parser.tab.c" /* yacc.c:1646 */ 2851 + #line 2852 "parser.tab.c" /* yacc.c:1646 */ 2815 2852 break; 2816 2853 2817 - case 45: 2818 - #line 407 "parser.y" /* yacc.c:1646 */ 2854 + case 47: 2855 + #line 418 "parser.y" /* yacc.c:1646 */ 2819 2856 { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[-1].attr_list)); } 2820 - #line 2821 "parser.tab.c" /* yacc.c:1646 */ 2857 + #line 2858 "parser.tab.c" /* yacc.c:1646 */ 2821 2858 break; 2822 2859 2823 - case 46: 2824 - #line 408 "parser.y" /* yacc.c:1646 */ 2860 + case 48: 2861 + #line 419 "parser.y" /* yacc.c:1646 */ 2825 2862 { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_union_attrs((yyvsp[-1].attr_list)); } 2826 - #line 2827 "parser.tab.c" /* yacc.c:1646 */ 2863 + #line 2864 "parser.tab.c" /* yacc.c:1646 */ 2827 2864 break; 2828 2865 2829 - case 47: 2830 - #line 411 "parser.y" /* yacc.c:1646 */ 2866 + case 49: 2867 + #line 422 "parser.y" /* yacc.c:1646 */ 2831 2868 { (yyval.str) = (yyvsp[-1].str); } 2832 - #line 2833 "parser.tab.c" /* yacc.c:1646 */ 2869 + #line 2870 "parser.tab.c" /* yacc.c:1646 */ 2833 2870 break; 2834 2871 2835 - case 48: 2836 - #line 413 "parser.y" /* yacc.c:1646 */ 2872 + case 50: 2873 + #line 424 "parser.y" /* yacc.c:1646 */ 2837 2874 { assert(yychar == YYEMPTY); 2838 2875 (yyval.import) = xmalloc(sizeof(struct _import_t)); 2839 2876 (yyval.import)->name = (yyvsp[-1].str); 2840 2877 (yyval.import)->import_performed = do_import((yyvsp[-1].str)); 2841 2878 if (!(yyval.import)->import_performed) yychar = aEOF; 2842 2879 } 2843 - #line 2844 "parser.tab.c" /* yacc.c:1646 */ 2880 + #line 2881 "parser.tab.c" /* yacc.c:1646 */ 2844 2881 break; 2845 2882 2846 - case 49: 2847 - #line 421 "parser.y" /* yacc.c:1646 */ 2883 + case 51: 2884 + #line 432 "parser.y" /* yacc.c:1646 */ 2848 2885 { (yyval.str) = (yyvsp[-2].import)->name; 2849 2886 if ((yyvsp[-2].import)->import_performed) pop_import(); 2850 2887 free((yyvsp[-2].import)); 2851 2888 } 2852 - #line 2853 "parser.tab.c" /* yacc.c:1646 */ 2889 + #line 2890 "parser.tab.c" /* yacc.c:1646 */ 2853 2890 break; 2854 2891 2855 - case 50: 2856 - #line 428 "parser.y" /* yacc.c:1646 */ 2892 + case 52: 2893 + #line 440 "parser.y" /* yacc.c:1646 */ 2857 2894 { (yyval.str) = (yyvsp[-2].str); if(!parse_only) add_importlib((yyvsp[-2].str)); } 2858 - #line 2859 "parser.tab.c" /* yacc.c:1646 */ 2895 + #line 2896 "parser.tab.c" /* yacc.c:1646 */ 2859 2896 break; 2860 2897 2861 - case 51: 2862 - #line 431 "parser.y" /* yacc.c:1646 */ 2898 + case 53: 2899 + #line 446 "parser.y" /* yacc.c:1646 */ 2863 2900 { (yyval.str) = (yyvsp[0].str); } 2864 - #line 2865 "parser.tab.c" /* yacc.c:1646 */ 2901 + #line 2902 "parser.tab.c" /* yacc.c:1646 */ 2865 2902 break; 2866 2903 2867 - case 52: 2868 - #line 432 "parser.y" /* yacc.c:1646 */ 2904 + case 54: 2905 + #line 447 "parser.y" /* yacc.c:1646 */ 2869 2906 { (yyval.str) = (yyvsp[0].str); } 2870 - #line 2871 "parser.tab.c" /* yacc.c:1646 */ 2907 + #line 2908 "parser.tab.c" /* yacc.c:1646 */ 2871 2908 break; 2872 2909 2873 - case 53: 2874 - #line 434 "parser.y" /* yacc.c:1646 */ 2910 + case 55: 2911 + #line 449 "parser.y" /* yacc.c:1646 */ 2875 2912 { (yyval.typelib) = make_library((yyvsp[-1].str), check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list))); 2913 + /* ifdef __REACTOS__ */ 2876 2914 if (!parse_only) start_typelib((yyval.typelib)); 2915 + /* else 2916 + if (!parse_only && do_typelib) current_typelib = $$; 2917 + */ 2877 2918 } 2878 - #line 2879 "parser.tab.c" /* yacc.c:1646 */ 2919 + #line 2920 "parser.tab.c" /* yacc.c:1646 */ 2879 2920 break; 2880 2921 2881 - case 54: 2882 - #line 439 "parser.y" /* yacc.c:1646 */ 2922 + case 56: 2923 + #line 459 "parser.y" /* yacc.c:1646 */ 2883 2924 { (yyval.typelib) = (yyvsp[-3].typelib); 2884 2925 (yyval.typelib)->stmts = (yyvsp[-2].stmt_list); 2885 2926 if (!parse_only) end_typelib(); 2886 2927 } 2887 - #line 2888 "parser.tab.c" /* yacc.c:1646 */ 2928 + #line 2929 "parser.tab.c" /* yacc.c:1646 */ 2888 2929 break; 2889 2930 2890 - case 55: 2891 - #line 445 "parser.y" /* yacc.c:1646 */ 2931 + case 57: 2932 + #line 468 "parser.y" /* yacc.c:1646 */ 2892 2933 { (yyval.var_list) = NULL; } 2893 - #line 2894 "parser.tab.c" /* yacc.c:1646 */ 2934 + #line 2935 "parser.tab.c" /* yacc.c:1646 */ 2894 2935 break; 2895 2936 2896 - case 57: 2897 - #line 449 "parser.y" /* yacc.c:1646 */ 2937 + case 59: 2938 + #line 472 "parser.y" /* yacc.c:1646 */ 2898 2939 { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); } 2899 - #line 2900 "parser.tab.c" /* yacc.c:1646 */ 2940 + #line 2941 "parser.tab.c" /* yacc.c:1646 */ 2900 2941 break; 2901 2942 2902 - case 58: 2903 - #line 450 "parser.y" /* yacc.c:1646 */ 2943 + case 60: 2944 + #line 473 "parser.y" /* yacc.c:1646 */ 2904 2945 { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) ); } 2905 - #line 2906 "parser.tab.c" /* yacc.c:1646 */ 2946 + #line 2947 "parser.tab.c" /* yacc.c:1646 */ 2906 2947 break; 2907 2948 2908 - case 60: 2909 - #line 454 "parser.y" /* yacc.c:1646 */ 2949 + case 62: 2950 + #line 477 "parser.y" /* yacc.c:1646 */ 2910 2951 { (yyval.var_list) = append_var( (yyvsp[-2].var_list), make_var(strdup("...")) ); } 2911 - #line 2912 "parser.tab.c" /* yacc.c:1646 */ 2952 + #line 2953 "parser.tab.c" /* yacc.c:1646 */ 2912 2953 break; 2913 2954 2914 - case 61: 2915 - #line 458 "parser.y" /* yacc.c:1646 */ 2955 + case 63: 2956 + #line 481 "parser.y" /* yacc.c:1646 */ 2916 2957 { if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER) 2917 2958 error_loc("invalid storage class for function parameter\n"); 2918 2959 (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE); 2919 2960 free((yyvsp[-1].declspec)); free((yyvsp[0].declarator)); 2920 2961 } 2921 - #line 2922 "parser.tab.c" /* yacc.c:1646 */ 2962 + #line 2963 "parser.tab.c" /* yacc.c:1646 */ 2922 2963 break; 2923 2964 2924 - case 62: 2925 - #line 463 "parser.y" /* yacc.c:1646 */ 2965 + case 64: 2966 + #line 486 "parser.y" /* yacc.c:1646 */ 2926 2967 { if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER) 2927 2968 error_loc("invalid storage class for function parameter\n"); 2928 2969 (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE); 2929 2970 free((yyvsp[-1].declspec)); free((yyvsp[0].declarator)); 2930 2971 } 2931 - #line 2932 "parser.tab.c" /* yacc.c:1646 */ 2972 + #line 2973 "parser.tab.c" /* yacc.c:1646 */ 2932 2973 break; 2933 2974 2934 - case 63: 2935 - #line 470 "parser.y" /* yacc.c:1646 */ 2975 + case 65: 2976 + #line 493 "parser.y" /* yacc.c:1646 */ 2936 2977 { (yyval.expr) = (yyvsp[-1].expr); 2937 - if (!(yyval.expr)->is_const) 2938 - error_loc("array dimension is not an integer constant\n"); 2978 + if (!(yyval.expr)->is_const || (yyval.expr)->cval <= 0) 2979 + error_loc("array dimension is not a positive integer constant\n"); 2939 2980 } 2940 - #line 2941 "parser.tab.c" /* yacc.c:1646 */ 2981 + #line 2982 "parser.tab.c" /* yacc.c:1646 */ 2941 2982 break; 2942 2983 2943 - case 64: 2944 - #line 474 "parser.y" /* yacc.c:1646 */ 2984 + case 66: 2985 + #line 497 "parser.y" /* yacc.c:1646 */ 2945 2986 { (yyval.expr) = make_expr(EXPR_VOID); } 2946 - #line 2947 "parser.tab.c" /* yacc.c:1646 */ 2987 + #line 2988 "parser.tab.c" /* yacc.c:1646 */ 2947 2988 break; 2948 2989 2949 - case 65: 2950 - #line 475 "parser.y" /* yacc.c:1646 */ 2990 + case 67: 2991 + #line 498 "parser.y" /* yacc.c:1646 */ 2951 2992 { (yyval.expr) = make_expr(EXPR_VOID); } 2952 - #line 2953 "parser.tab.c" /* yacc.c:1646 */ 2993 + #line 2994 "parser.tab.c" /* yacc.c:1646 */ 2953 2994 break; 2954 2995 2955 - case 66: 2956 - #line 478 "parser.y" /* yacc.c:1646 */ 2996 + case 68: 2997 + #line 501 "parser.y" /* yacc.c:1646 */ 2957 2998 { (yyval.attr_list) = NULL; } 2958 - #line 2959 "parser.tab.c" /* yacc.c:1646 */ 2999 + #line 3000 "parser.tab.c" /* yacc.c:1646 */ 2959 3000 break; 2960 3001 2961 - case 68: 2962 - #line 483 "parser.y" /* yacc.c:1646 */ 3002 + case 70: 3003 + #line 506 "parser.y" /* yacc.c:1646 */ 2963 3004 { (yyval.attr_list) = (yyvsp[-1].attr_list); } 2964 - #line 2965 "parser.tab.c" /* yacc.c:1646 */ 3005 + #line 3006 "parser.tab.c" /* yacc.c:1646 */ 2965 3006 break; 2966 3007 2967 - case 69: 2968 - #line 486 "parser.y" /* yacc.c:1646 */ 3008 + case 71: 3009 + #line 509 "parser.y" /* yacc.c:1646 */ 2969 3010 { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); } 2970 - #line 2971 "parser.tab.c" /* yacc.c:1646 */ 3011 + #line 3012 "parser.tab.c" /* yacc.c:1646 */ 2971 3012 break; 2972 3013 2973 - case 70: 2974 - #line 487 "parser.y" /* yacc.c:1646 */ 3014 + case 72: 3015 + #line 510 "parser.y" /* yacc.c:1646 */ 2975 3016 { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); } 2976 - #line 2977 "parser.tab.c" /* yacc.c:1646 */ 3017 + #line 3018 "parser.tab.c" /* yacc.c:1646 */ 2977 3018 break; 2978 3019 2979 - case 71: 2980 - #line 488 "parser.y" /* yacc.c:1646 */ 3020 + case 73: 3021 + #line 511 "parser.y" /* yacc.c:1646 */ 2981 3022 { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); } 2982 - #line 2983 "parser.tab.c" /* yacc.c:1646 */ 3023 + #line 3024 "parser.tab.c" /* yacc.c:1646 */ 2983 3024 break; 2984 3025 2985 - case 72: 2986 - #line 491 "parser.y" /* yacc.c:1646 */ 3026 + case 74: 3027 + #line 514 "parser.y" /* yacc.c:1646 */ 2987 3028 { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); } 2988 - #line 2989 "parser.tab.c" /* yacc.c:1646 */ 3029 + #line 3030 "parser.tab.c" /* yacc.c:1646 */ 2989 3030 break; 2990 3031 2991 - case 73: 2992 - #line 492 "parser.y" /* yacc.c:1646 */ 3032 + case 75: 3033 + #line 515 "parser.y" /* yacc.c:1646 */ 2993 3034 { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); } 2994 - #line 2995 "parser.tab.c" /* yacc.c:1646 */ 3035 + #line 3036 "parser.tab.c" /* yacc.c:1646 */ 2995 3036 break; 2996 3037 2997 - case 74: 2998 - #line 495 "parser.y" /* yacc.c:1646 */ 3038 + case 76: 3039 + #line 518 "parser.y" /* yacc.c:1646 */ 2999 3040 { (yyval.attr) = NULL; } 3000 - #line 3001 "parser.tab.c" /* yacc.c:1646 */ 3041 + #line 3042 "parser.tab.c" /* yacc.c:1646 */ 3001 3042 break; 3002 3043 3003 - case 75: 3004 - #line 496 "parser.y" /* yacc.c:1646 */ 3044 + case 77: 3045 + #line 519 "parser.y" /* yacc.c:1646 */ 3005 3046 { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); } 3006 - #line 3007 "parser.tab.c" /* yacc.c:1646 */ 3047 + #line 3048 "parser.tab.c" /* yacc.c:1646 */ 3007 3048 break; 3008 3049 3009 - case 76: 3010 - #line 497 "parser.y" /* yacc.c:1646 */ 3050 + case 78: 3051 + #line 520 "parser.y" /* yacc.c:1646 */ 3011 3052 { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[-1].str)); } 3012 - #line 3013 "parser.tab.c" /* yacc.c:1646 */ 3053 + #line 3054 "parser.tab.c" /* yacc.c:1646 */ 3013 3054 break; 3014 3055 3015 - case 77: 3016 - #line 498 "parser.y" /* yacc.c:1646 */ 3056 + case 79: 3057 + #line 521 "parser.y" /* yacc.c:1646 */ 3017 3058 { (yyval.attr) = make_attr(ATTR_APPOBJECT); } 3018 - #line 3019 "parser.tab.c" /* yacc.c:1646 */ 3059 + #line 3060 "parser.tab.c" /* yacc.c:1646 */ 3019 3060 break; 3020 3061 3021 - case 78: 3022 - #line 499 "parser.y" /* yacc.c:1646 */ 3062 + case 80: 3063 + #line 522 "parser.y" /* yacc.c:1646 */ 3023 3064 { (yyval.attr) = make_attr(ATTR_ASYNC); } 3024 - #line 3025 "parser.tab.c" /* yacc.c:1646 */ 3065 + #line 3066 "parser.tab.c" /* yacc.c:1646 */ 3025 3066 break; 3026 3067 3027 - case 79: 3028 - #line 500 "parser.y" /* yacc.c:1646 */ 3068 + case 81: 3069 + #line 523 "parser.y" /* yacc.c:1646 */ 3029 3070 { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); } 3030 - #line 3031 "parser.tab.c" /* yacc.c:1646 */ 3071 + #line 3072 "parser.tab.c" /* yacc.c:1646 */ 3031 3072 break; 3032 3073 3033 - case 80: 3034 - #line 501 "parser.y" /* yacc.c:1646 */ 3074 + case 82: 3075 + #line 524 "parser.y" /* yacc.c:1646 */ 3035 3076 { (yyval.attr) = make_attr(ATTR_BINDABLE); } 3036 - #line 3037 "parser.tab.c" /* yacc.c:1646 */ 3077 + #line 3078 "parser.tab.c" /* yacc.c:1646 */ 3037 3078 break; 3038 3079 3039 - case 81: 3040 - #line 502 "parser.y" /* yacc.c:1646 */ 3080 + case 83: 3081 + #line 525 "parser.y" /* yacc.c:1646 */ 3041 3082 { (yyval.attr) = make_attr(ATTR_BROADCAST); } 3042 - #line 3043 "parser.tab.c" /* yacc.c:1646 */ 3083 + #line 3084 "parser.tab.c" /* yacc.c:1646 */ 3043 3084 break; 3044 3085 3045 - case 82: 3046 - #line 503 "parser.y" /* yacc.c:1646 */ 3086 + case 84: 3087 + #line 526 "parser.y" /* yacc.c:1646 */ 3047 3088 { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); } 3048 - #line 3049 "parser.tab.c" /* yacc.c:1646 */ 3089 + #line 3090 "parser.tab.c" /* yacc.c:1646 */ 3049 3090 break; 3050 3091 3051 - case 83: 3052 - #line 504 "parser.y" /* yacc.c:1646 */ 3092 + case 85: 3093 + #line 527 "parser.y" /* yacc.c:1646 */ 3053 3094 { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); } 3054 - #line 3055 "parser.tab.c" /* yacc.c:1646 */ 3095 + #line 3096 "parser.tab.c" /* yacc.c:1646 */ 3055 3096 break; 3056 3097 3057 - case 84: 3058 - #line 505 "parser.y" /* yacc.c:1646 */ 3098 + case 86: 3099 + #line 528 "parser.y" /* yacc.c:1646 */ 3059 3100 { (yyval.attr) = make_attr(ATTR_CODE); } 3060 - #line 3061 "parser.tab.c" /* yacc.c:1646 */ 3101 + #line 3102 "parser.tab.c" /* yacc.c:1646 */ 3061 3102 break; 3062 3103 3063 - case 85: 3064 - #line 506 "parser.y" /* yacc.c:1646 */ 3104 + case 87: 3105 + #line 529 "parser.y" /* yacc.c:1646 */ 3065 3106 { (yyval.attr) = make_attr(ATTR_COMMSTATUS); } 3066 - #line 3067 "parser.tab.c" /* yacc.c:1646 */ 3107 + #line 3108 "parser.tab.c" /* yacc.c:1646 */ 3067 3108 break; 3068 3109 3069 - case 86: 3070 - #line 507 "parser.y" /* yacc.c:1646 */ 3110 + case 88: 3111 + #line 530 "parser.y" /* yacc.c:1646 */ 3071 3112 { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); } 3072 - #line 3073 "parser.tab.c" /* yacc.c:1646 */ 3113 + #line 3114 "parser.tab.c" /* yacc.c:1646 */ 3073 3114 break; 3074 3115 3075 - case 87: 3076 - #line 508 "parser.y" /* yacc.c:1646 */ 3116 + case 89: 3117 + #line 531 "parser.y" /* yacc.c:1646 */ 3077 3118 { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ } 3078 - #line 3079 "parser.tab.c" /* yacc.c:1646 */ 3119 + #line 3120 "parser.tab.c" /* yacc.c:1646 */ 3079 3120 break; 3080 3121 3081 - case 88: 3082 - #line 509 "parser.y" /* yacc.c:1646 */ 3122 + case 90: 3123 + #line 532 "parser.y" /* yacc.c:1646 */ 3083 3124 { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ } 3084 - #line 3085 "parser.tab.c" /* yacc.c:1646 */ 3125 + #line 3126 "parser.tab.c" /* yacc.c:1646 */ 3085 3126 break; 3086 3127 3087 - case 89: 3088 - #line 510 "parser.y" /* yacc.c:1646 */ 3128 + case 91: 3129 + #line 533 "parser.y" /* yacc.c:1646 */ 3089 3130 { (yyval.attr) = make_attr(ATTR_CONTROL); } 3090 - #line 3091 "parser.tab.c" /* yacc.c:1646 */ 3131 + #line 3132 "parser.tab.c" /* yacc.c:1646 */ 3091 3132 break; 3092 3133 3093 - case 90: 3094 - #line 511 "parser.y" /* yacc.c:1646 */ 3134 + case 92: 3135 + #line 534 "parser.y" /* yacc.c:1646 */ 3095 3136 { (yyval.attr) = make_attr(ATTR_DECODE); } 3096 - #line 3097 "parser.tab.c" /* yacc.c:1646 */ 3137 + #line 3138 "parser.tab.c" /* yacc.c:1646 */ 3097 3138 break; 3098 3139 3099 - case 91: 3100 - #line 512 "parser.y" /* yacc.c:1646 */ 3140 + case 93: 3141 + #line 535 "parser.y" /* yacc.c:1646 */ 3101 3142 { (yyval.attr) = make_attr(ATTR_DEFAULT); } 3102 - #line 3103 "parser.tab.c" /* yacc.c:1646 */ 3143 + #line 3144 "parser.tab.c" /* yacc.c:1646 */ 3103 3144 break; 3104 3145 3105 - case 92: 3106 - #line 513 "parser.y" /* yacc.c:1646 */ 3146 + case 94: 3147 + #line 536 "parser.y" /* yacc.c:1646 */ 3107 3148 { (yyval.attr) = make_attr(ATTR_DEFAULTBIND); } 3108 - #line 3109 "parser.tab.c" /* yacc.c:1646 */ 3149 + #line 3150 "parser.tab.c" /* yacc.c:1646 */ 3109 3150 break; 3110 3151 3111 - case 93: 3112 - #line 514 "parser.y" /* yacc.c:1646 */ 3152 + case 95: 3153 + #line 537 "parser.y" /* yacc.c:1646 */ 3113 3154 { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); } 3114 - #line 3115 "parser.tab.c" /* yacc.c:1646 */ 3155 + #line 3156 "parser.tab.c" /* yacc.c:1646 */ 3115 3156 break; 3116 3157 3117 - case 94: 3118 - #line 515 "parser.y" /* yacc.c:1646 */ 3158 + case 96: 3159 + #line 538 "parser.y" /* yacc.c:1646 */ 3119 3160 { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[-1].expr)); } 3120 - #line 3121 "parser.tab.c" /* yacc.c:1646 */ 3161 + #line 3162 "parser.tab.c" /* yacc.c:1646 */ 3121 3162 break; 3122 3163 3123 - case 95: 3124 - #line 516 "parser.y" /* yacc.c:1646 */ 3164 + case 97: 3165 + #line 539 "parser.y" /* yacc.c:1646 */ 3125 3166 { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); } 3126 - #line 3127 "parser.tab.c" /* yacc.c:1646 */ 3167 + #line 3168 "parser.tab.c" /* yacc.c:1646 */ 3127 3168 break; 3128 3169 3129 - case 96: 3130 - #line 517 "parser.y" /* yacc.c:1646 */ 3170 + case 98: 3171 + #line 540 "parser.y" /* yacc.c:1646 */ 3131 3172 { (yyval.attr) = make_attr(ATTR_DISABLECONSISTENCYCHECK); } 3132 - #line 3133 "parser.tab.c" /* yacc.c:1646 */ 3173 + #line 3174 "parser.tab.c" /* yacc.c:1646 */ 3133 3174 break; 3134 3175 3135 - case 97: 3136 - #line 518 "parser.y" /* yacc.c:1646 */ 3176 + case 99: 3177 + #line 541 "parser.y" /* yacc.c:1646 */ 3137 3178 { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); } 3138 - #line 3139 "parser.tab.c" /* yacc.c:1646 */ 3179 + #line 3180 "parser.tab.c" /* yacc.c:1646 */ 3139 3180 break; 3140 3181 3141 - case 98: 3142 - #line 519 "parser.y" /* yacc.c:1646 */ 3182 + case 100: 3183 + #line 542 "parser.y" /* yacc.c:1646 */ 3143 3184 { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); } 3144 - #line 3145 "parser.tab.c" /* yacc.c:1646 */ 3185 + #line 3186 "parser.tab.c" /* yacc.c:1646 */ 3145 3186 break; 3146 3187 3147 - case 99: 3148 - #line 520 "parser.y" /* yacc.c:1646 */ 3188 + case 101: 3189 + #line 543 "parser.y" /* yacc.c:1646 */ 3149 3190 { (yyval.attr) = make_attr(ATTR_DUAL); } 3150 - #line 3151 "parser.tab.c" /* yacc.c:1646 */ 3191 + #line 3192 "parser.tab.c" /* yacc.c:1646 */ 3151 3192 break; 3152 3193 3153 - case 100: 3154 - #line 521 "parser.y" /* yacc.c:1646 */ 3194 + case 102: 3195 + #line 544 "parser.y" /* yacc.c:1646 */ 3155 3196 { (yyval.attr) = make_attr(ATTR_ENABLEALLOCATE); } 3156 - #line 3157 "parser.tab.c" /* yacc.c:1646 */ 3197 + #line 3198 "parser.tab.c" /* yacc.c:1646 */ 3157 3198 break; 3158 3199 3159 - case 101: 3160 - #line 522 "parser.y" /* yacc.c:1646 */ 3200 + case 103: 3201 + #line 545 "parser.y" /* yacc.c:1646 */ 3161 3202 { (yyval.attr) = make_attr(ATTR_ENCODE); } 3162 - #line 3163 "parser.tab.c" /* yacc.c:1646 */ 3203 + #line 3204 "parser.tab.c" /* yacc.c:1646 */ 3163 3204 break; 3164 3205 3165 - case 102: 3166 - #line 523 "parser.y" /* yacc.c:1646 */ 3206 + case 104: 3207 + #line 546 "parser.y" /* yacc.c:1646 */ 3167 3208 { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); } 3168 - #line 3169 "parser.tab.c" /* yacc.c:1646 */ 3209 + #line 3210 "parser.tab.c" /* yacc.c:1646 */ 3169 3210 break; 3170 3211 3171 - case 103: 3172 - #line 524 "parser.y" /* yacc.c:1646 */ 3212 + case 105: 3213 + #line 547 "parser.y" /* yacc.c:1646 */ 3173 3214 { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[-1].expr)); } 3174 - #line 3175 "parser.tab.c" /* yacc.c:1646 */ 3215 + #line 3216 "parser.tab.c" /* yacc.c:1646 */ 3175 3216 break; 3176 3217 3177 - case 104: 3178 - #line 525 "parser.y" /* yacc.c:1646 */ 3218 + case 106: 3219 + #line 548 "parser.y" /* yacc.c:1646 */ 3179 3220 { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); } 3180 - #line 3181 "parser.tab.c" /* yacc.c:1646 */ 3221 + #line 3222 "parser.tab.c" /* yacc.c:1646 */ 3181 3222 break; 3182 3223 3183 - case 105: 3184 - #line 526 "parser.y" /* yacc.c:1646 */ 3224 + case 107: 3225 + #line 549 "parser.y" /* yacc.c:1646 */ 3185 3226 { (yyval.attr) = make_attr(ATTR_FAULTSTATUS); } 3186 - #line 3187 "parser.tab.c" /* yacc.c:1646 */ 3227 + #line 3228 "parser.tab.c" /* yacc.c:1646 */ 3187 3228 break; 3188 3229 3189 - case 106: 3190 - #line 527 "parser.y" /* yacc.c:1646 */ 3230 + case 108: 3231 + #line 550 "parser.y" /* yacc.c:1646 */ 3191 3232 { (yyval.attr) = make_attr(ATTR_FORCEALLOCATE); } 3192 - #line 3193 "parser.tab.c" /* yacc.c:1646 */ 3233 + #line 3234 "parser.tab.c" /* yacc.c:1646 */ 3193 3234 break; 3194 3235 3195 - case 107: 3196 - #line 528 "parser.y" /* yacc.c:1646 */ 3236 + case 109: 3237 + #line 551 "parser.y" /* yacc.c:1646 */ 3197 3238 { (yyval.attr) = make_attr(ATTR_HANDLE); } 3198 - #line 3199 "parser.tab.c" /* yacc.c:1646 */ 3239 + #line 3240 "parser.tab.c" /* yacc.c:1646 */ 3199 3240 break; 3200 3241 3201 - case 108: 3202 - #line 529 "parser.y" /* yacc.c:1646 */ 3242 + case 110: 3243 + #line 552 "parser.y" /* yacc.c:1646 */ 3203 3244 { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); } 3204 - #line 3205 "parser.tab.c" /* yacc.c:1646 */ 3245 + #line 3246 "parser.tab.c" /* yacc.c:1646 */ 3205 3246 break; 3206 3247 3207 - case 109: 3208 - #line 530 "parser.y" /* yacc.c:1646 */ 3248 + case 111: 3249 + #line 553 "parser.y" /* yacc.c:1646 */ 3209 3250 { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-1].str)); } 3210 - #line 3211 "parser.tab.c" /* yacc.c:1646 */ 3251 + #line 3252 "parser.tab.c" /* yacc.c:1646 */ 3211 3252 break; 3212 3253 3213 - case 110: 3214 - #line 531 "parser.y" /* yacc.c:1646 */ 3254 + case 112: 3255 + #line 554 "parser.y" /* yacc.c:1646 */ 3215 3256 { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[-1].str)); } 3216 - #line 3217 "parser.tab.c" /* yacc.c:1646 */ 3257 + #line 3258 "parser.tab.c" /* yacc.c:1646 */ 3217 3258 break; 3218 3259 3219 - case 111: 3220 - #line 532 "parser.y" /* yacc.c:1646 */ 3260 + case 113: 3261 + #line 555 "parser.y" /* yacc.c:1646 */ 3221 3262 { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[-1].expr)); } 3222 - #line 3223 "parser.tab.c" /* yacc.c:1646 */ 3263 + #line 3264 "parser.tab.c" /* yacc.c:1646 */ 3223 3264 break; 3224 3265 3225 - case 112: 3226 - #line 533 "parser.y" /* yacc.c:1646 */ 3266 + case 114: 3267 + #line 556 "parser.y" /* yacc.c:1646 */ 3227 3268 { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[-1].str)); } 3228 - #line 3229 "parser.tab.c" /* yacc.c:1646 */ 3269 + #line 3270 "parser.tab.c" /* yacc.c:1646 */ 3229 3270 break; 3230 3271 3231 - case 113: 3232 - #line 534 "parser.y" /* yacc.c:1646 */ 3272 + case 115: 3273 + #line 557 "parser.y" /* yacc.c:1646 */ 3233 3274 { (yyval.attr) = make_attr(ATTR_HIDDEN); } 3234 - #line 3235 "parser.tab.c" /* yacc.c:1646 */ 3275 + #line 3276 "parser.tab.c" /* yacc.c:1646 */ 3235 3276 break; 3236 3277 3237 - case 114: 3238 - #line 535 "parser.y" /* yacc.c:1646 */ 3278 + case 116: 3279 + #line 558 "parser.y" /* yacc.c:1646 */ 3239 3280 { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[-1].expr)); } 3240 - #line 3241 "parser.tab.c" /* yacc.c:1646 */ 3281 + #line 3282 "parser.tab.c" /* yacc.c:1646 */ 3241 3282 break; 3242 3283 3243 - case 115: 3244 - #line 536 "parser.y" /* yacc.c:1646 */ 3284 + case 117: 3285 + #line 559 "parser.y" /* yacc.c:1646 */ 3245 3286 { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); } 3246 - #line 3247 "parser.tab.c" /* yacc.c:1646 */ 3287 + #line 3288 "parser.tab.c" /* yacc.c:1646 */ 3247 3288 break; 3248 3289 3249 - case 116: 3250 - #line 537 "parser.y" /* yacc.c:1646 */ 3290 + case 118: 3291 + #line 560 "parser.y" /* yacc.c:1646 */ 3251 3292 { (yyval.attr) = make_attr(ATTR_IGNORE); } 3252 - #line 3253 "parser.tab.c" /* yacc.c:1646 */ 3293 + #line 3294 "parser.tab.c" /* yacc.c:1646 */ 3253 3294 break; 3254 3295 3255 - case 117: 3256 - #line 538 "parser.y" /* yacc.c:1646 */ 3296 + case 119: 3297 + #line 561 "parser.y" /* yacc.c:1646 */ 3257 3298 { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[-1].expr)); } 3258 - #line 3259 "parser.tab.c" /* yacc.c:1646 */ 3299 + #line 3300 "parser.tab.c" /* yacc.c:1646 */ 3259 3300 break; 3260 3301 3261 - case 118: 3262 - #line 539 "parser.y" /* yacc.c:1646 */ 3302 + case 120: 3303 + #line 562 "parser.y" /* yacc.c:1646 */ 3263 3304 { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); } 3264 - #line 3265 "parser.tab.c" /* yacc.c:1646 */ 3305 + #line 3306 "parser.tab.c" /* yacc.c:1646 */ 3265 3306 break; 3266 3307 3267 - case 119: 3268 - #line 540 "parser.y" /* yacc.c:1646 */ 3308 + case 121: 3309 + #line 563 "parser.y" /* yacc.c:1646 */ 3269 3310 { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[-1].var)); } 3270 - #line 3271 "parser.tab.c" /* yacc.c:1646 */ 3311 + #line 3312 "parser.tab.c" /* yacc.c:1646 */ 3271 3312 break; 3272 3313 3273 - case 120: 3274 - #line 541 "parser.y" /* yacc.c:1646 */ 3314 + case 122: 3315 + #line 564 "parser.y" /* yacc.c:1646 */ 3275 3316 { (yyval.attr) = make_attr(ATTR_IN); } 3276 - #line 3277 "parser.tab.c" /* yacc.c:1646 */ 3317 + #line 3318 "parser.tab.c" /* yacc.c:1646 */ 3277 3318 break; 3278 3319 3279 - case 121: 3280 - #line 542 "parser.y" /* yacc.c:1646 */ 3320 + case 123: 3321 + #line 565 "parser.y" /* yacc.c:1646 */ 3281 3322 { (yyval.attr) = make_attr(ATTR_INPUTSYNC); } 3282 - #line 3283 "parser.tab.c" /* yacc.c:1646 */ 3323 + #line 3324 "parser.tab.c" /* yacc.c:1646 */ 3283 3324 break; 3284 3325 3285 - case 122: 3286 - #line 543 "parser.y" /* yacc.c:1646 */ 3326 + case 124: 3327 + #line 566 "parser.y" /* yacc.c:1646 */ 3287 3328 { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[-1].expr_list)); } 3288 - #line 3289 "parser.tab.c" /* yacc.c:1646 */ 3329 + #line 3330 "parser.tab.c" /* yacc.c:1646 */ 3289 3330 break; 3290 3331 3291 - case 123: 3292 - #line 544 "parser.y" /* yacc.c:1646 */ 3332 + case 125: 3333 + #line 567 "parser.y" /* yacc.c:1646 */ 3293 3334 { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[-1].expr)); } 3294 - #line 3295 "parser.tab.c" /* yacc.c:1646 */ 3335 + #line 3336 "parser.tab.c" /* yacc.c:1646 */ 3295 3336 break; 3296 3337 3297 - case 124: 3298 - #line 545 "parser.y" /* yacc.c:1646 */ 3338 + case 126: 3339 + #line 568 "parser.y" /* yacc.c:1646 */ 3299 3340 { (yyval.attr) = make_attr(ATTR_PARAMLCID); } 3300 - #line 3301 "parser.tab.c" /* yacc.c:1646 */ 3341 + #line 3342 "parser.tab.c" /* yacc.c:1646 */ 3301 3342 break; 3302 3343 3303 - case 125: 3304 - #line 546 "parser.y" /* yacc.c:1646 */ 3344 + case 127: 3345 + #line 569 "parser.y" /* yacc.c:1646 */ 3305 3346 { (yyval.attr) = make_attr(ATTR_LICENSED); } 3306 - #line 3307 "parser.tab.c" /* yacc.c:1646 */ 3347 + #line 3348 "parser.tab.c" /* yacc.c:1646 */ 3307 3348 break; 3308 3349 3309 - case 126: 3310 - #line 547 "parser.y" /* yacc.c:1646 */ 3350 + case 128: 3351 + #line 570 "parser.y" /* yacc.c:1646 */ 3311 3352 { (yyval.attr) = make_attr(ATTR_LOCAL); } 3312 - #line 3313 "parser.tab.c" /* yacc.c:1646 */ 3353 + #line 3354 "parser.tab.c" /* yacc.c:1646 */ 3313 3354 break; 3314 3355 3315 - case 127: 3316 - #line 548 "parser.y" /* yacc.c:1646 */ 3356 + case 129: 3357 + #line 571 "parser.y" /* yacc.c:1646 */ 3317 3358 { (yyval.attr) = make_attr(ATTR_MAYBE); } 3318 - #line 3319 "parser.tab.c" /* yacc.c:1646 */ 3359 + #line 3360 "parser.tab.c" /* yacc.c:1646 */ 3319 3360 break; 3320 3361 3321 - case 128: 3322 - #line 549 "parser.y" /* yacc.c:1646 */ 3362 + case 130: 3363 + #line 572 "parser.y" /* yacc.c:1646 */ 3323 3364 { (yyval.attr) = make_attr(ATTR_MESSAGE); } 3324 - #line 3325 "parser.tab.c" /* yacc.c:1646 */ 3365 + #line 3366 "parser.tab.c" /* yacc.c:1646 */ 3325 3366 break; 3326 3367 3327 - case 129: 3328 - #line 550 "parser.y" /* yacc.c:1646 */ 3368 + case 131: 3369 + #line 573 "parser.y" /* yacc.c:1646 */ 3329 3370 { (yyval.attr) = make_attr(ATTR_NOCODE); } 3330 - #line 3331 "parser.tab.c" /* yacc.c:1646 */ 3371 + #line 3372 "parser.tab.c" /* yacc.c:1646 */ 3331 3372 break; 3332 3373 3333 - case 130: 3334 - #line 551 "parser.y" /* yacc.c:1646 */ 3374 + case 132: 3375 + #line 574 "parser.y" /* yacc.c:1646 */ 3335 3376 { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); } 3336 - #line 3337 "parser.tab.c" /* yacc.c:1646 */ 3377 + #line 3378 "parser.tab.c" /* yacc.c:1646 */ 3337 3378 break; 3338 3379 3339 - case 131: 3340 - #line 552 "parser.y" /* yacc.c:1646 */ 3380 + case 133: 3381 + #line 575 "parser.y" /* yacc.c:1646 */ 3341 3382 { (yyval.attr) = make_attr(ATTR_NONCREATABLE); } 3342 - #line 3343 "parser.tab.c" /* yacc.c:1646 */ 3383 + #line 3384 "parser.tab.c" /* yacc.c:1646 */ 3343 3384 break; 3344 3385 3345 - case 132: 3346 - #line 553 "parser.y" /* yacc.c:1646 */ 3386 + case 134: 3387 + #line 576 "parser.y" /* yacc.c:1646 */ 3347 3388 { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); } 3348 - #line 3349 "parser.tab.c" /* yacc.c:1646 */ 3389 + #line 3390 "parser.tab.c" /* yacc.c:1646 */ 3349 3390 break; 3350 3391 3351 - case 133: 3352 - #line 554 "parser.y" /* yacc.c:1646 */ 3392 + case 135: 3393 + #line 577 "parser.y" /* yacc.c:1646 */ 3353 3394 { (yyval.attr) = make_attr(ATTR_NOTIFY); } 3354 - #line 3355 "parser.tab.c" /* yacc.c:1646 */ 3395 + #line 3396 "parser.tab.c" /* yacc.c:1646 */ 3355 3396 break; 3356 3397 3357 - case 134: 3358 - #line 555 "parser.y" /* yacc.c:1646 */ 3398 + case 136: 3399 + #line 578 "parser.y" /* yacc.c:1646 */ 3359 3400 { (yyval.attr) = make_attr(ATTR_NOTIFYFLAG); } 3360 - #line 3361 "parser.tab.c" /* yacc.c:1646 */ 3401 + #line 3402 "parser.tab.c" /* yacc.c:1646 */ 3361 3402 break; 3362 3403 3363 - case 135: 3364 - #line 556 "parser.y" /* yacc.c:1646 */ 3404 + case 137: 3405 + #line 579 "parser.y" /* yacc.c:1646 */ 3365 3406 { (yyval.attr) = make_attr(ATTR_OBJECT); } 3366 - #line 3367 "parser.tab.c" /* yacc.c:1646 */ 3407 + #line 3408 "parser.tab.c" /* yacc.c:1646 */ 3367 3408 break; 3368 3409 3369 - case 136: 3370 - #line 557 "parser.y" /* yacc.c:1646 */ 3410 + case 138: 3411 + #line 580 "parser.y" /* yacc.c:1646 */ 3371 3412 { (yyval.attr) = make_attr(ATTR_ODL); } 3372 - #line 3373 "parser.tab.c" /* yacc.c:1646 */ 3413 + #line 3414 "parser.tab.c" /* yacc.c:1646 */ 3373 3414 break; 3374 3415 3375 - case 137: 3376 - #line 558 "parser.y" /* yacc.c:1646 */ 3416 + case 139: 3417 + #line 581 "parser.y" /* yacc.c:1646 */ 3377 3418 { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); } 3378 - #line 3379 "parser.tab.c" /* yacc.c:1646 */ 3419 + #line 3420 "parser.tab.c" /* yacc.c:1646 */ 3379 3420 break; 3380 3421 3381 - case 138: 3382 - #line 559 "parser.y" /* yacc.c:1646 */ 3422 + case 140: 3423 + #line 582 "parser.y" /* yacc.c:1646 */ 3383 3424 { (yyval.attr) = make_attrp(ATTR_OPTIMIZE, (yyvsp[-1].str)); } 3384 - #line 3385 "parser.tab.c" /* yacc.c:1646 */ 3425 + #line 3426 "parser.tab.c" /* yacc.c:1646 */ 3385 3426 break; 3386 3427 3387 - case 139: 3388 - #line 560 "parser.y" /* yacc.c:1646 */ 3428 + case 141: 3429 + #line 583 "parser.y" /* yacc.c:1646 */ 3389 3430 { (yyval.attr) = make_attr(ATTR_OPTIONAL); } 3390 - #line 3391 "parser.tab.c" /* yacc.c:1646 */ 3431 + #line 3432 "parser.tab.c" /* yacc.c:1646 */ 3391 3432 break; 3392 3433 3393 - case 140: 3394 - #line 561 "parser.y" /* yacc.c:1646 */ 3434 + case 142: 3435 + #line 584 "parser.y" /* yacc.c:1646 */ 3395 3436 { (yyval.attr) = make_attr(ATTR_OUT); } 3396 - #line 3397 "parser.tab.c" /* yacc.c:1646 */ 3437 + #line 3438 "parser.tab.c" /* yacc.c:1646 */ 3397 3438 break; 3398 3439 3399 - case 141: 3400 - #line 562 "parser.y" /* yacc.c:1646 */ 3440 + case 143: 3441 + #line 585 "parser.y" /* yacc.c:1646 */ 3401 3442 { (yyval.attr) = make_attr(ATTR_PARTIALIGNORE); } 3402 - #line 3403 "parser.tab.c" /* yacc.c:1646 */ 3443 + #line 3444 "parser.tab.c" /* yacc.c:1646 */ 3403 3444 break; 3404 3445 3405 - case 142: 3406 - #line 563 "parser.y" /* yacc.c:1646 */ 3446 + case 144: 3447 + #line 586 "parser.y" /* yacc.c:1646 */ 3407 3448 { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[-1].num)); } 3408 - #line 3409 "parser.tab.c" /* yacc.c:1646 */ 3449 + #line 3450 "parser.tab.c" /* yacc.c:1646 */ 3409 3450 break; 3410 3451 3411 - case 143: 3412 - #line 564 "parser.y" /* yacc.c:1646 */ 3452 + case 145: 3453 + #line 587 "parser.y" /* yacc.c:1646 */ 3413 3454 { (yyval.attr) = make_attrp(ATTR_PROGID, (yyvsp[-1].str)); } 3414 - #line 3415 "parser.tab.c" /* yacc.c:1646 */ 3455 + #line 3456 "parser.tab.c" /* yacc.c:1646 */ 3415 3456 break; 3416 3457 3417 - case 144: 3418 - #line 565 "parser.y" /* yacc.c:1646 */ 3458 + case 146: 3459 + #line 588 "parser.y" /* yacc.c:1646 */ 3419 3460 { (yyval.attr) = make_attr(ATTR_PROPGET); } 3420 - #line 3421 "parser.tab.c" /* yacc.c:1646 */ 3461 + #line 3462 "parser.tab.c" /* yacc.c:1646 */ 3421 3462 break; 3422 3463 3423 - case 145: 3424 - #line 566 "parser.y" /* yacc.c:1646 */ 3464 + case 147: 3465 + #line 589 "parser.y" /* yacc.c:1646 */ 3425 3466 { (yyval.attr) = make_attr(ATTR_PROPPUT); } 3426 - #line 3427 "parser.tab.c" /* yacc.c:1646 */ 3467 + #line 3468 "parser.tab.c" /* yacc.c:1646 */ 3427 3468 break; 3428 3469 3429 - case 146: 3430 - #line 567 "parser.y" /* yacc.c:1646 */ 3470 + case 148: 3471 + #line 590 "parser.y" /* yacc.c:1646 */ 3431 3472 { (yyval.attr) = make_attr(ATTR_PROPPUTREF); } 3432 - #line 3433 "parser.tab.c" /* yacc.c:1646 */ 3473 + #line 3474 "parser.tab.c" /* yacc.c:1646 */ 3433 3474 break; 3434 3475 3435 - case 147: 3436 - #line 568 "parser.y" /* yacc.c:1646 */ 3476 + case 149: 3477 + #line 591 "parser.y" /* yacc.c:1646 */ 3437 3478 { (yyval.attr) = make_attr(ATTR_PROXY); } 3438 - #line 3439 "parser.tab.c" /* yacc.c:1646 */ 3479 + #line 3480 "parser.tab.c" /* yacc.c:1646 */ 3439 3480 break; 3440 3481 3441 - case 148: 3442 - #line 569 "parser.y" /* yacc.c:1646 */ 3482 + case 150: 3483 + #line 592 "parser.y" /* yacc.c:1646 */ 3443 3484 { (yyval.attr) = make_attr(ATTR_PUBLIC); } 3444 - #line 3445 "parser.tab.c" /* yacc.c:1646 */ 3485 + #line 3486 "parser.tab.c" /* yacc.c:1646 */ 3445 3486 break; 3446 3487 3447 - case 149: 3448 - #line 571 "parser.y" /* yacc.c:1646 */ 3488 + case 151: 3489 + #line 594 "parser.y" /* yacc.c:1646 */ 3449 3490 { expr_list_t *list = append_expr( NULL, (yyvsp[-3].expr) ); 3450 3491 list = append_expr( list, (yyvsp[-1].expr) ); 3451 3492 (yyval.attr) = make_attrp(ATTR_RANGE, list); } 3452 - #line 3453 "parser.tab.c" /* yacc.c:1646 */ 3493 + #line 3494 "parser.tab.c" /* yacc.c:1646 */ 3453 3494 break; 3454 3495 3455 - case 150: 3456 - #line 574 "parser.y" /* yacc.c:1646 */ 3496 + case 152: 3497 + #line 597 "parser.y" /* yacc.c:1646 */ 3457 3498 { (yyval.attr) = make_attr(ATTR_READONLY); } 3458 - #line 3459 "parser.tab.c" /* yacc.c:1646 */ 3499 + #line 3500 "parser.tab.c" /* yacc.c:1646 */ 3459 3500 break; 3460 3501 3461 - case 151: 3462 - #line 575 "parser.y" /* yacc.c:1646 */ 3502 + case 153: 3503 + #line 598 "parser.y" /* yacc.c:1646 */ 3463 3504 { (yyval.attr) = make_attrp(ATTR_REPRESENTAS, (yyvsp[-1].type)); } 3464 - #line 3465 "parser.tab.c" /* yacc.c:1646 */ 3505 + #line 3506 "parser.tab.c" /* yacc.c:1646 */ 3465 3506 break; 3466 3507 3467 - case 152: 3468 - #line 576 "parser.y" /* yacc.c:1646 */ 3508 + case 154: 3509 + #line 599 "parser.y" /* yacc.c:1646 */ 3469 3510 { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); } 3470 - #line 3471 "parser.tab.c" /* yacc.c:1646 */ 3511 + #line 3512 "parser.tab.c" /* yacc.c:1646 */ 3471 3512 break; 3472 3513 3473 - case 153: 3474 - #line 577 "parser.y" /* yacc.c:1646 */ 3514 + case 155: 3515 + #line 600 "parser.y" /* yacc.c:1646 */ 3475 3516 { (yyval.attr) = make_attr(ATTR_RESTRICTED); } 3476 - #line 3477 "parser.tab.c" /* yacc.c:1646 */ 3517 + #line 3518 "parser.tab.c" /* yacc.c:1646 */ 3477 3518 break; 3478 3519 3479 - case 154: 3480 - #line 578 "parser.y" /* yacc.c:1646 */ 3520 + case 156: 3521 + #line 601 "parser.y" /* yacc.c:1646 */ 3481 3522 { (yyval.attr) = make_attr(ATTR_RETVAL); } 3482 - #line 3483 "parser.tab.c" /* yacc.c:1646 */ 3523 + #line 3524 "parser.tab.c" /* yacc.c:1646 */ 3483 3524 break; 3484 3525 3485 - case 155: 3486 - #line 579 "parser.y" /* yacc.c:1646 */ 3526 + case 157: 3527 + #line 602 "parser.y" /* yacc.c:1646 */ 3487 3528 { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[-1].expr_list)); } 3488 - #line 3489 "parser.tab.c" /* yacc.c:1646 */ 3529 + #line 3530 "parser.tab.c" /* yacc.c:1646 */ 3489 3530 break; 3490 3531 3491 - case 156: 3492 - #line 580 "parser.y" /* yacc.c:1646 */ 3532 + case 158: 3533 + #line 603 "parser.y" /* yacc.c:1646 */ 3493 3534 { (yyval.attr) = make_attr(ATTR_SOURCE); } 3494 - #line 3495 "parser.tab.c" /* yacc.c:1646 */ 3535 + #line 3536 "parser.tab.c" /* yacc.c:1646 */ 3495 3536 break; 3496 3537 3497 - case 157: 3498 - #line 581 "parser.y" /* yacc.c:1646 */ 3538 + case 159: 3539 + #line 604 "parser.y" /* yacc.c:1646 */ 3499 3540 { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); } 3500 - #line 3501 "parser.tab.c" /* yacc.c:1646 */ 3541 + #line 3542 "parser.tab.c" /* yacc.c:1646 */ 3501 3542 break; 3502 3543 3503 - case 158: 3504 - #line 582 "parser.y" /* yacc.c:1646 */ 3544 + case 160: 3545 + #line 605 "parser.y" /* yacc.c:1646 */ 3505 3546 { (yyval.attr) = make_attr(ATTR_STRING); } 3506 - #line 3507 "parser.tab.c" /* yacc.c:1646 */ 3547 + #line 3548 "parser.tab.c" /* yacc.c:1646 */ 3507 3548 break; 3508 3549 3509 - case 159: 3510 - #line 583 "parser.y" /* yacc.c:1646 */ 3550 + case 161: 3551 + #line 606 "parser.y" /* yacc.c:1646 */ 3511 3552 { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[-1].expr)); } 3512 - #line 3513 "parser.tab.c" /* yacc.c:1646 */ 3553 + #line 3554 "parser.tab.c" /* yacc.c:1646 */ 3513 3554 break; 3514 3555 3515 - case 160: 3516 - #line 584 "parser.y" /* yacc.c:1646 */ 3556 + case 162: 3557 + #line 607 "parser.y" /* yacc.c:1646 */ 3517 3558 { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[-1].type)); } 3518 - #line 3519 "parser.tab.c" /* yacc.c:1646 */ 3559 + #line 3560 "parser.tab.c" /* yacc.c:1646 */ 3519 3560 break; 3520 3561 3521 - case 161: 3522 - #line 585 "parser.y" /* yacc.c:1646 */ 3562 + case 163: 3563 + #line 608 "parser.y" /* yacc.c:1646 */ 3523 3564 { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[-1].type)); } 3524 - #line 3525 "parser.tab.c" /* yacc.c:1646 */ 3565 + #line 3566 "parser.tab.c" /* yacc.c:1646 */ 3525 3566 break; 3526 3567 3527 - case 162: 3528 - #line 586 "parser.y" /* yacc.c:1646 */ 3568 + case 164: 3569 + #line 609 "parser.y" /* yacc.c:1646 */ 3529 3570 { (yyval.attr) = make_attrv(ATTR_THREADING, (yyvsp[-1].num)); } 3530 - #line 3531 "parser.tab.c" /* yacc.c:1646 */ 3571 + #line 3572 "parser.tab.c" /* yacc.c:1646 */ 3531 3572 break; 3532 3573 3533 - case 163: 3534 - #line 587 "parser.y" /* yacc.c:1646 */ 3574 + case 165: 3575 + #line 610 "parser.y" /* yacc.c:1646 */ 3535 3576 { (yyval.attr) = make_attr(ATTR_UIDEFAULT); } 3536 - #line 3537 "parser.tab.c" /* yacc.c:1646 */ 3577 + #line 3578 "parser.tab.c" /* yacc.c:1646 */ 3537 3578 break; 3538 3579 3539 - case 164: 3540 - #line 588 "parser.y" /* yacc.c:1646 */ 3580 + case 166: 3581 + #line 611 "parser.y" /* yacc.c:1646 */ 3541 3582 { (yyval.attr) = make_attr(ATTR_USESGETLASTERROR); } 3542 - #line 3543 "parser.tab.c" /* yacc.c:1646 */ 3583 + #line 3584 "parser.tab.c" /* yacc.c:1646 */ 3543 3584 break; 3544 3585 3545 - case 165: 3546 - #line 589 "parser.y" /* yacc.c:1646 */ 3586 + case 167: 3587 + #line 612 "parser.y" /* yacc.c:1646 */ 3547 3588 { (yyval.attr) = make_attrp(ATTR_USERMARSHAL, (yyvsp[-1].type)); } 3548 - #line 3549 "parser.tab.c" /* yacc.c:1646 */ 3589 + #line 3590 "parser.tab.c" /* yacc.c:1646 */ 3549 3590 break; 3550 3591 3551 - case 166: 3552 - #line 590 "parser.y" /* yacc.c:1646 */ 3592 + case 168: 3593 + #line 613 "parser.y" /* yacc.c:1646 */ 3553 3594 { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[-1].uuid)); } 3554 - #line 3555 "parser.tab.c" /* yacc.c:1646 */ 3595 + #line 3596 "parser.tab.c" /* yacc.c:1646 */ 3555 3596 break; 3556 3597 3557 - case 167: 3558 - #line 591 "parser.y" /* yacc.c:1646 */ 3598 + case 169: 3599 + #line 614 "parser.y" /* yacc.c:1646 */ 3559 3600 { (yyval.attr) = make_attrp(ATTR_ASYNCUUID, (yyvsp[-1].uuid)); } 3560 - #line 3561 "parser.tab.c" /* yacc.c:1646 */ 3601 + #line 3602 "parser.tab.c" /* yacc.c:1646 */ 3561 3602 break; 3562 3603 3563 - case 168: 3564 - #line 592 "parser.y" /* yacc.c:1646 */ 3604 + case 170: 3605 + #line 615 "parser.y" /* yacc.c:1646 */ 3565 3606 { (yyval.attr) = make_attr(ATTR_V1ENUM); } 3566 - #line 3567 "parser.tab.c" /* yacc.c:1646 */ 3607 + #line 3608 "parser.tab.c" /* yacc.c:1646 */ 3567 3608 break; 3568 3609 3569 - case 169: 3570 - #line 593 "parser.y" /* yacc.c:1646 */ 3610 + case 171: 3611 + #line 616 "parser.y" /* yacc.c:1646 */ 3571 3612 { (yyval.attr) = make_attr(ATTR_VARARG); } 3572 - #line 3573 "parser.tab.c" /* yacc.c:1646 */ 3613 + #line 3614 "parser.tab.c" /* yacc.c:1646 */ 3573 3614 break; 3574 3615 3575 - case 170: 3576 - #line 594 "parser.y" /* yacc.c:1646 */ 3616 + case 172: 3617 + #line 617 "parser.y" /* yacc.c:1646 */ 3577 3618 { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[-1].num)); } 3578 - #line 3579 "parser.tab.c" /* yacc.c:1646 */ 3619 + #line 3620 "parser.tab.c" /* yacc.c:1646 */ 3579 3620 break; 3580 3621 3581 - case 171: 3582 - #line 595 "parser.y" /* yacc.c:1646 */ 3622 + case 173: 3623 + #line 618 "parser.y" /* yacc.c:1646 */ 3583 3624 { (yyval.attr) = make_attrp(ATTR_VIPROGID, (yyvsp[-1].str)); } 3584 - #line 3585 "parser.tab.c" /* yacc.c:1646 */ 3625 + #line 3626 "parser.tab.c" /* yacc.c:1646 */ 3585 3626 break; 3586 3627 3587 - case 172: 3588 - #line 596 "parser.y" /* yacc.c:1646 */ 3628 + case 174: 3629 + #line 619 "parser.y" /* yacc.c:1646 */ 3589 3630 { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[-1].type)); } 3590 - #line 3591 "parser.tab.c" /* yacc.c:1646 */ 3631 + #line 3632 "parser.tab.c" /* yacc.c:1646 */ 3591 3632 break; 3592 3633 3593 - case 173: 3594 - #line 597 "parser.y" /* yacc.c:1646 */ 3634 + case 175: 3635 + #line 620 "parser.y" /* yacc.c:1646 */ 3595 3636 { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[0].num)); } 3596 - #line 3597 "parser.tab.c" /* yacc.c:1646 */ 3637 + #line 3638 "parser.tab.c" /* yacc.c:1646 */ 3597 3638 break; 3598 3639 3599 - case 175: 3600 - #line 602 "parser.y" /* yacc.c:1646 */ 3640 + case 177: 3641 + #line 625 "parser.y" /* yacc.c:1646 */ 3601 3642 { if (!is_valid_uuid((yyvsp[0].str))) 3602 3643 error_loc("invalid UUID: %s\n", (yyvsp[0].str)); 3603 3644 (yyval.uuid) = parse_uuid((yyvsp[0].str)); } 3604 - #line 3605 "parser.tab.c" /* yacc.c:1646 */ 3645 + #line 3646 "parser.tab.c" /* yacc.c:1646 */ 3605 3646 break; 3606 3647 3607 - case 176: 3608 - #line 607 "parser.y" /* yacc.c:1646 */ 3648 + case 178: 3649 + #line 630 "parser.y" /* yacc.c:1646 */ 3609 3650 { (yyval.str) = xstrdup("__cdecl"); } 3610 - #line 3611 "parser.tab.c" /* yacc.c:1646 */ 3651 + #line 3652 "parser.tab.c" /* yacc.c:1646 */ 3611 3652 break; 3612 3653 3613 - case 177: 3614 - #line 608 "parser.y" /* yacc.c:1646 */ 3654 + case 179: 3655 + #line 631 "parser.y" /* yacc.c:1646 */ 3615 3656 { (yyval.str) = xstrdup("__fastcall"); } 3616 - #line 3617 "parser.tab.c" /* yacc.c:1646 */ 3657 + #line 3658 "parser.tab.c" /* yacc.c:1646 */ 3617 3658 break; 3618 3659 3619 - case 178: 3620 - #line 609 "parser.y" /* yacc.c:1646 */ 3660 + case 180: 3661 + #line 632 "parser.y" /* yacc.c:1646 */ 3621 3662 { (yyval.str) = xstrdup("__pascal"); } 3622 - #line 3623 "parser.tab.c" /* yacc.c:1646 */ 3663 + #line 3664 "parser.tab.c" /* yacc.c:1646 */ 3623 3664 break; 3624 3665 3625 - case 179: 3626 - #line 610 "parser.y" /* yacc.c:1646 */ 3666 + case 181: 3667 + #line 633 "parser.y" /* yacc.c:1646 */ 3627 3668 { (yyval.str) = xstrdup("__stdcall"); } 3628 - #line 3629 "parser.tab.c" /* yacc.c:1646 */ 3669 + #line 3670 "parser.tab.c" /* yacc.c:1646 */ 3629 3670 break; 3630 3671 3631 - case 180: 3632 - #line 613 "parser.y" /* yacc.c:1646 */ 3672 + case 182: 3673 + #line 636 "parser.y" /* yacc.c:1646 */ 3633 3674 { (yyval.var_list) = NULL; } 3634 - #line 3635 "parser.tab.c" /* yacc.c:1646 */ 3675 + #line 3676 "parser.tab.c" /* yacc.c:1646 */ 3635 3676 break; 3636 3677 3637 - case 181: 3638 - #line 614 "parser.y" /* yacc.c:1646 */ 3678 + case 183: 3679 + #line 637 "parser.y" /* yacc.c:1646 */ 3639 3680 { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); } 3640 - #line 3641 "parser.tab.c" /* yacc.c:1646 */ 3681 + #line 3682 "parser.tab.c" /* yacc.c:1646 */ 3641 3682 break; 3642 3683 3643 - case 182: 3644 - #line 617 "parser.y" /* yacc.c:1646 */ 3684 + case 184: 3685 + #line 640 "parser.y" /* yacc.c:1646 */ 3645 3686 { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, (yyvsp[-2].expr) )); 3646 3687 (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL); 3647 3688 (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a ); 3648 3689 } 3649 - #line 3650 "parser.tab.c" /* yacc.c:1646 */ 3690 + #line 3691 "parser.tab.c" /* yacc.c:1646 */ 3650 3691 break; 3651 3692 3652 - case 183: 3653 - #line 621 "parser.y" /* yacc.c:1646 */ 3693 + case 185: 3694 + #line 644 "parser.y" /* yacc.c:1646 */ 3654 3695 { attr_t *a = make_attr(ATTR_DEFAULT); 3655 3696 (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL); 3656 3697 (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a ); 3657 3698 } 3658 - #line 3659 "parser.tab.c" /* yacc.c:1646 */ 3699 + #line 3700 "parser.tab.c" /* yacc.c:1646 */ 3659 3700 break; 3660 3701 3661 - case 184: 3662 - #line 627 "parser.y" /* yacc.c:1646 */ 3702 + case 186: 3703 + #line 650 "parser.y" /* yacc.c:1646 */ 3663 3704 { (yyval.var_list) = NULL; } 3664 - #line 3665 "parser.tab.c" /* yacc.c:1646 */ 3705 + #line 3706 "parser.tab.c" /* yacc.c:1646 */ 3665 3706 break; 3666 3707 3667 - case 185: 3668 - #line 628 "parser.y" /* yacc.c:1646 */ 3708 + case 187: 3709 + #line 651 "parser.y" /* yacc.c:1646 */ 3669 3710 { (yyval.var_list) = (yyvsp[-1].var_list); } 3670 - #line 3671 "parser.tab.c" /* yacc.c:1646 */ 3711 + #line 3712 "parser.tab.c" /* yacc.c:1646 */ 3671 3712 break; 3672 3713 3673 - case 187: 3674 - #line 632 "parser.y" /* yacc.c:1646 */ 3714 + case 189: 3715 + #line 655 "parser.y" /* yacc.c:1646 */ 3675 3716 { if (!(yyvsp[0].var)->eval) 3676 3717 (yyvsp[0].var)->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */); 3677 3718 (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); 3678 3719 } 3679 - #line 3680 "parser.tab.c" /* yacc.c:1646 */ 3720 + #line 3721 "parser.tab.c" /* yacc.c:1646 */ 3680 3721 break; 3681 3722 3682 - case 188: 3683 - #line 636 "parser.y" /* yacc.c:1646 */ 3723 + case 190: 3724 + #line 659 "parser.y" /* yacc.c:1646 */ 3684 3725 { if (!(yyvsp[0].var)->eval) 3685 3726 { 3686 3727 var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry ); ··· 3691 3732 } 3692 3733 (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) ); 3693 3734 } 3694 - #line 3695 "parser.tab.c" /* yacc.c:1646 */ 3735 + #line 3736 "parser.tab.c" /* yacc.c:1646 */ 3695 3736 break; 3696 3737 3697 - case 189: 3698 - #line 648 "parser.y" /* yacc.c:1646 */ 3738 + case 191: 3739 + #line 671 "parser.y" /* yacc.c:1646 */ 3699 3740 { (yyval.var) = reg_const((yyvsp[-2].var)); 3700 3741 (yyval.var)->eval = (yyvsp[0].expr); 3701 3742 (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0); 3702 3743 } 3703 - #line 3704 "parser.tab.c" /* yacc.c:1646 */ 3744 + #line 3745 "parser.tab.c" /* yacc.c:1646 */ 3704 3745 break; 3705 3746 3706 - case 190: 3707 - #line 652 "parser.y" /* yacc.c:1646 */ 3747 + case 192: 3748 + #line 675 "parser.y" /* yacc.c:1646 */ 3708 3749 { (yyval.var) = reg_const((yyvsp[0].var)); 3709 3750 (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0); 3710 3751 } 3711 - #line 3712 "parser.tab.c" /* yacc.c:1646 */ 3752 + #line 3753 "parser.tab.c" /* yacc.c:1646 */ 3712 3753 break; 3713 3754 3714 - case 191: 3715 - #line 657 "parser.y" /* yacc.c:1646 */ 3755 + case 193: 3756 + #line 680 "parser.y" /* yacc.c:1646 */ 3716 3757 { (yyval.type) = type_new_enum((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); } 3717 - #line 3718 "parser.tab.c" /* yacc.c:1646 */ 3758 + #line 3759 "parser.tab.c" /* yacc.c:1646 */ 3718 3759 break; 3719 3760 3720 - case 192: 3721 - #line 660 "parser.y" /* yacc.c:1646 */ 3761 + case 194: 3762 + #line 683 "parser.y" /* yacc.c:1646 */ 3722 3763 { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); } 3723 - #line 3724 "parser.tab.c" /* yacc.c:1646 */ 3764 + #line 3765 "parser.tab.c" /* yacc.c:1646 */ 3724 3765 break; 3725 3766 3726 - case 193: 3727 - #line 661 "parser.y" /* yacc.c:1646 */ 3767 + case 195: 3768 + #line 684 "parser.y" /* yacc.c:1646 */ 3728 3769 { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); } 3729 - #line 3730 "parser.tab.c" /* yacc.c:1646 */ 3770 + #line 3771 "parser.tab.c" /* yacc.c:1646 */ 3730 3771 break; 3731 3772 3732 - case 194: 3733 - #line 664 "parser.y" /* yacc.c:1646 */ 3773 + case 196: 3774 + #line 687 "parser.y" /* yacc.c:1646 */ 3734 3775 { (yyval.expr) = make_expr(EXPR_VOID); } 3735 - #line 3736 "parser.tab.c" /* yacc.c:1646 */ 3776 + #line 3777 "parser.tab.c" /* yacc.c:1646 */ 3736 3777 break; 3737 3778 3738 - case 196: 3739 - #line 668 "parser.y" /* yacc.c:1646 */ 3779 + case 198: 3780 + #line 691 "parser.y" /* yacc.c:1646 */ 3740 3781 { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[0].num)); } 3741 - #line 3742 "parser.tab.c" /* yacc.c:1646 */ 3782 + #line 3783 "parser.tab.c" /* yacc.c:1646 */ 3742 3783 break; 3743 3784 3744 - case 197: 3745 - #line 669 "parser.y" /* yacc.c:1646 */ 3785 + case 199: 3786 + #line 692 "parser.y" /* yacc.c:1646 */ 3746 3787 { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[0].num)); } 3747 - #line 3748 "parser.tab.c" /* yacc.c:1646 */ 3788 + #line 3789 "parser.tab.c" /* yacc.c:1646 */ 3748 3789 break; 3749 3790 3750 - case 198: 3751 - #line 670 "parser.y" /* yacc.c:1646 */ 3791 + case 200: 3792 + #line 693 "parser.y" /* yacc.c:1646 */ 3752 3793 { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[0].dbl)); } 3753 - #line 3754 "parser.tab.c" /* yacc.c:1646 */ 3794 + #line 3795 "parser.tab.c" /* yacc.c:1646 */ 3754 3795 break; 3755 3796 3756 - case 199: 3757 - #line 671 "parser.y" /* yacc.c:1646 */ 3797 + case 201: 3798 + #line 694 "parser.y" /* yacc.c:1646 */ 3758 3799 { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); } 3759 - #line 3760 "parser.tab.c" /* yacc.c:1646 */ 3800 + #line 3801 "parser.tab.c" /* yacc.c:1646 */ 3760 3801 break; 3761 3802 3762 - case 200: 3763 - #line 672 "parser.y" /* yacc.c:1646 */ 3803 + case 202: 3804 + #line 695 "parser.y" /* yacc.c:1646 */ 3764 3805 { (yyval.expr) = make_exprl(EXPR_NUM, 0); } 3765 - #line 3766 "parser.tab.c" /* yacc.c:1646 */ 3806 + #line 3807 "parser.tab.c" /* yacc.c:1646 */ 3766 3807 break; 3767 3808 3768 - case 201: 3769 - #line 673 "parser.y" /* yacc.c:1646 */ 3809 + case 203: 3810 + #line 696 "parser.y" /* yacc.c:1646 */ 3770 3811 { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); } 3771 - #line 3772 "parser.tab.c" /* yacc.c:1646 */ 3812 + #line 3813 "parser.tab.c" /* yacc.c:1646 */ 3772 3813 break; 3773 3814 3774 - case 202: 3775 - #line 674 "parser.y" /* yacc.c:1646 */ 3815 + case 204: 3816 + #line 697 "parser.y" /* yacc.c:1646 */ 3776 3817 { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[0].str)); } 3777 - #line 3778 "parser.tab.c" /* yacc.c:1646 */ 3818 + #line 3819 "parser.tab.c" /* yacc.c:1646 */ 3778 3819 break; 3779 3820 3780 - case 203: 3781 - #line 675 "parser.y" /* yacc.c:1646 */ 3821 + case 205: 3822 + #line 698 "parser.y" /* yacc.c:1646 */ 3782 3823 { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[0].str)); } 3783 - #line 3784 "parser.tab.c" /* yacc.c:1646 */ 3824 + #line 3825 "parser.tab.c" /* yacc.c:1646 */ 3784 3825 break; 3785 3826 3786 - case 204: 3787 - #line 676 "parser.y" /* yacc.c:1646 */ 3827 + case 206: 3828 + #line 699 "parser.y" /* yacc.c:1646 */ 3788 3829 { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[0].str)); } 3789 - #line 3790 "parser.tab.c" /* yacc.c:1646 */ 3830 + #line 3831 "parser.tab.c" /* yacc.c:1646 */ 3790 3831 break; 3791 3832 3792 - case 205: 3793 - #line 677 "parser.y" /* yacc.c:1646 */ 3833 + case 207: 3834 + #line 700 "parser.y" /* yacc.c:1646 */ 3794 3835 { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str)); } 3795 - #line 3796 "parser.tab.c" /* yacc.c:1646 */ 3836 + #line 3837 "parser.tab.c" /* yacc.c:1646 */ 3796 3837 break; 3797 3838 3798 - case 206: 3799 - #line 678 "parser.y" /* yacc.c:1646 */ 3839 + case 208: 3840 + #line 701 "parser.y" /* yacc.c:1646 */ 3800 3841 { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 3801 - #line 3802 "parser.tab.c" /* yacc.c:1646 */ 3842 + #line 3843 "parser.tab.c" /* yacc.c:1646 */ 3802 3843 break; 3803 3844 3804 - case 207: 3805 - #line 679 "parser.y" /* yacc.c:1646 */ 3845 + case 209: 3846 + #line 702 "parser.y" /* yacc.c:1646 */ 3806 3847 { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3807 - #line 3808 "parser.tab.c" /* yacc.c:1646 */ 3848 + #line 3849 "parser.tab.c" /* yacc.c:1646 */ 3808 3849 break; 3809 3850 3810 - case 208: 3811 - #line 680 "parser.y" /* yacc.c:1646 */ 3851 + case 210: 3852 + #line 703 "parser.y" /* yacc.c:1646 */ 3812 3853 { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3813 - #line 3814 "parser.tab.c" /* yacc.c:1646 */ 3854 + #line 3855 "parser.tab.c" /* yacc.c:1646 */ 3814 3855 break; 3815 3856 3816 - case 209: 3817 - #line 681 "parser.y" /* yacc.c:1646 */ 3857 + case 211: 3858 + #line 704 "parser.y" /* yacc.c:1646 */ 3818 3859 { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[-2].expr), (yyvsp[0].expr)); } 3819 - #line 3820 "parser.tab.c" /* yacc.c:1646 */ 3860 + #line 3861 "parser.tab.c" /* yacc.c:1646 */ 3820 3861 break; 3821 3862 3822 - case 210: 3823 - #line 682 "parser.y" /* yacc.c:1646 */ 3863 + case 212: 3864 + #line 705 "parser.y" /* yacc.c:1646 */ 3824 3865 { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3825 - #line 3826 "parser.tab.c" /* yacc.c:1646 */ 3866 + #line 3867 "parser.tab.c" /* yacc.c:1646 */ 3826 3867 break; 3827 3868 3828 - case 211: 3829 - #line 683 "parser.y" /* yacc.c:1646 */ 3869 + case 213: 3870 + #line 706 "parser.y" /* yacc.c:1646 */ 3830 3871 { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3831 - #line 3832 "parser.tab.c" /* yacc.c:1646 */ 3872 + #line 3873 "parser.tab.c" /* yacc.c:1646 */ 3832 3873 break; 3833 3874 3834 - case 212: 3835 - #line 684 "parser.y" /* yacc.c:1646 */ 3875 + case 214: 3876 + #line 707 "parser.y" /* yacc.c:1646 */ 3836 3877 { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3837 - #line 3838 "parser.tab.c" /* yacc.c:1646 */ 3878 + #line 3879 "parser.tab.c" /* yacc.c:1646 */ 3838 3879 break; 3839 3880 3840 - case 213: 3841 - #line 685 "parser.y" /* yacc.c:1646 */ 3881 + case 215: 3882 + #line 708 "parser.y" /* yacc.c:1646 */ 3842 3883 { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3843 - #line 3844 "parser.tab.c" /* yacc.c:1646 */ 3884 + #line 3885 "parser.tab.c" /* yacc.c:1646 */ 3844 3885 break; 3845 3886 3846 - case 214: 3847 - #line 686 "parser.y" /* yacc.c:1646 */ 3887 + case 216: 3888 + #line 709 "parser.y" /* yacc.c:1646 */ 3848 3889 { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3849 - #line 3850 "parser.tab.c" /* yacc.c:1646 */ 3890 + #line 3891 "parser.tab.c" /* yacc.c:1646 */ 3850 3891 break; 3851 3892 3852 - case 215: 3853 - #line 687 "parser.y" /* yacc.c:1646 */ 3893 + case 217: 3894 + #line 710 "parser.y" /* yacc.c:1646 */ 3854 3895 { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3855 - #line 3856 "parser.tab.c" /* yacc.c:1646 */ 3896 + #line 3897 "parser.tab.c" /* yacc.c:1646 */ 3856 3897 break; 3857 3898 3858 - case 216: 3859 - #line 688 "parser.y" /* yacc.c:1646 */ 3899 + case 218: 3900 + #line 711 "parser.y" /* yacc.c:1646 */ 3860 3901 { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3861 - #line 3862 "parser.tab.c" /* yacc.c:1646 */ 3902 + #line 3903 "parser.tab.c" /* yacc.c:1646 */ 3862 3903 break; 3863 3904 3864 - case 217: 3865 - #line 689 "parser.y" /* yacc.c:1646 */ 3905 + case 219: 3906 + #line 712 "parser.y" /* yacc.c:1646 */ 3866 3907 { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3867 - #line 3868 "parser.tab.c" /* yacc.c:1646 */ 3908 + #line 3909 "parser.tab.c" /* yacc.c:1646 */ 3868 3909 break; 3869 3910 3870 - case 218: 3871 - #line 690 "parser.y" /* yacc.c:1646 */ 3911 + case 220: 3912 + #line 713 "parser.y" /* yacc.c:1646 */ 3872 3913 { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3873 - #line 3874 "parser.tab.c" /* yacc.c:1646 */ 3914 + #line 3915 "parser.tab.c" /* yacc.c:1646 */ 3874 3915 break; 3875 3916 3876 - case 219: 3877 - #line 691 "parser.y" /* yacc.c:1646 */ 3917 + case 221: 3918 + #line 714 "parser.y" /* yacc.c:1646 */ 3878 3919 { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3879 - #line 3880 "parser.tab.c" /* yacc.c:1646 */ 3920 + #line 3921 "parser.tab.c" /* yacc.c:1646 */ 3880 3921 break; 3881 3922 3882 - case 220: 3883 - #line 692 "parser.y" /* yacc.c:1646 */ 3923 + case 222: 3924 + #line 715 "parser.y" /* yacc.c:1646 */ 3884 3925 { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3885 - #line 3886 "parser.tab.c" /* yacc.c:1646 */ 3926 + #line 3927 "parser.tab.c" /* yacc.c:1646 */ 3886 3927 break; 3887 3928 3888 - case 221: 3889 - #line 693 "parser.y" /* yacc.c:1646 */ 3929 + case 223: 3930 + #line 716 "parser.y" /* yacc.c:1646 */ 3890 3931 { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3891 - #line 3892 "parser.tab.c" /* yacc.c:1646 */ 3932 + #line 3933 "parser.tab.c" /* yacc.c:1646 */ 3892 3933 break; 3893 3934 3894 - case 222: 3895 - #line 694 "parser.y" /* yacc.c:1646 */ 3935 + case 224: 3936 + #line 717 "parser.y" /* yacc.c:1646 */ 3896 3937 { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3897 - #line 3898 "parser.tab.c" /* yacc.c:1646 */ 3938 + #line 3939 "parser.tab.c" /* yacc.c:1646 */ 3898 3939 break; 3899 3940 3900 - case 223: 3901 - #line 695 "parser.y" /* yacc.c:1646 */ 3941 + case 225: 3942 + #line 718 "parser.y" /* yacc.c:1646 */ 3902 3943 { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3903 - #line 3904 "parser.tab.c" /* yacc.c:1646 */ 3944 + #line 3945 "parser.tab.c" /* yacc.c:1646 */ 3904 3945 break; 3905 3946 3906 - case 224: 3907 - #line 696 "parser.y" /* yacc.c:1646 */ 3947 + case 226: 3948 + #line 719 "parser.y" /* yacc.c:1646 */ 3908 3949 { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); } 3909 - #line 3910 "parser.tab.c" /* yacc.c:1646 */ 3950 + #line 3951 "parser.tab.c" /* yacc.c:1646 */ 3910 3951 break; 3911 3952 3912 - case 225: 3913 - #line 697 "parser.y" /* yacc.c:1646 */ 3953 + case 227: 3954 + #line 720 "parser.y" /* yacc.c:1646 */ 3914 3955 { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[0].expr)); } 3915 - #line 3916 "parser.tab.c" /* yacc.c:1646 */ 3956 + #line 3957 "parser.tab.c" /* yacc.c:1646 */ 3916 3957 break; 3917 3958 3918 - case 226: 3919 - #line 698 "parser.y" /* yacc.c:1646 */ 3959 + case 228: 3960 + #line 721 "parser.y" /* yacc.c:1646 */ 3920 3961 { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[0].expr)); } 3921 - #line 3922 "parser.tab.c" /* yacc.c:1646 */ 3962 + #line 3963 "parser.tab.c" /* yacc.c:1646 */ 3922 3963 break; 3923 3964 3924 - case 227: 3925 - #line 699 "parser.y" /* yacc.c:1646 */ 3965 + case 229: 3966 + #line 722 "parser.y" /* yacc.c:1646 */ 3926 3967 { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[0].expr)); } 3927 - #line 3928 "parser.tab.c" /* yacc.c:1646 */ 3968 + #line 3969 "parser.tab.c" /* yacc.c:1646 */ 3928 3969 break; 3929 3970 3930 - case 228: 3931 - #line 700 "parser.y" /* yacc.c:1646 */ 3971 + case 230: 3972 + #line 723 "parser.y" /* yacc.c:1646 */ 3932 3973 { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[0].expr)); } 3933 - #line 3934 "parser.tab.c" /* yacc.c:1646 */ 3974 + #line 3975 "parser.tab.c" /* yacc.c:1646 */ 3934 3975 break; 3935 3976 3936 - case 229: 3937 - #line 701 "parser.y" /* yacc.c:1646 */ 3977 + case 231: 3978 + #line 724 "parser.y" /* yacc.c:1646 */ 3938 3979 { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[0].expr)); } 3939 - #line 3940 "parser.tab.c" /* yacc.c:1646 */ 3980 + #line 3981 "parser.tab.c" /* yacc.c:1646 */ 3940 3981 break; 3941 3982 3942 - case 230: 3943 - #line 702 "parser.y" /* yacc.c:1646 */ 3983 + case 232: 3984 + #line 725 "parser.y" /* yacc.c:1646 */ 3944 3985 { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[0].expr)); } 3945 - #line 3946 "parser.tab.c" /* yacc.c:1646 */ 3986 + #line 3987 "parser.tab.c" /* yacc.c:1646 */ 3946 3987 break; 3947 3988 3948 - case 231: 3949 - #line 703 "parser.y" /* yacc.c:1646 */ 3989 + case 233: 3990 + #line 726 "parser.y" /* yacc.c:1646 */ 3950 3991 { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[-2].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); } 3951 - #line 3952 "parser.tab.c" /* yacc.c:1646 */ 3992 + #line 3993 "parser.tab.c" /* yacc.c:1646 */ 3952 3993 break; 3953 3994 3954 - case 232: 3955 - #line 704 "parser.y" /* yacc.c:1646 */ 3995 + case 234: 3996 + #line 727 "parser.y" /* yacc.c:1646 */ 3956 3997 { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[-2].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); } 3957 - #line 3958 "parser.tab.c" /* yacc.c:1646 */ 3998 + #line 3999 "parser.tab.c" /* yacc.c:1646 */ 3958 3999 break; 3959 4000 3960 - case 233: 3961 - #line 706 "parser.y" /* yacc.c:1646 */ 4001 + case 235: 4002 + #line 729 "parser.y" /* yacc.c:1646 */ 3962 4003 { (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)); } 3963 - #line 3964 "parser.tab.c" /* yacc.c:1646 */ 4004 + #line 4005 "parser.tab.c" /* yacc.c:1646 */ 3964 4005 break; 3965 4006 3966 - case 234: 3967 - #line 708 "parser.y" /* yacc.c:1646 */ 4007 + case 236: 4008 + #line 731 "parser.y" /* yacc.c:1646 */ 3968 4009 { (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)); } 3969 - #line 3970 "parser.tab.c" /* yacc.c:1646 */ 4010 + #line 4011 "parser.tab.c" /* yacc.c:1646 */ 3970 4011 break; 3971 4012 3972 - case 235: 3973 - #line 709 "parser.y" /* yacc.c:1646 */ 4013 + case 237: 4014 + #line 732 "parser.y" /* yacc.c:1646 */ 3974 4015 { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 3975 - #line 3976 "parser.tab.c" /* yacc.c:1646 */ 4016 + #line 4017 "parser.tab.c" /* yacc.c:1646 */ 3976 4017 break; 3977 4018 3978 - case 236: 3979 - #line 710 "parser.y" /* yacc.c:1646 */ 4019 + case 238: 4020 + #line 733 "parser.y" /* yacc.c:1646 */ 3980 4021 { (yyval.expr) = (yyvsp[-1].expr); } 3981 - #line 3982 "parser.tab.c" /* yacc.c:1646 */ 4022 + #line 4023 "parser.tab.c" /* yacc.c:1646 */ 3982 4023 break; 3983 4024 3984 - case 237: 3985 - #line 713 "parser.y" /* yacc.c:1646 */ 4025 + case 239: 4026 + #line 736 "parser.y" /* yacc.c:1646 */ 3986 4027 { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); } 3987 - #line 3988 "parser.tab.c" /* yacc.c:1646 */ 4028 + #line 4029 "parser.tab.c" /* yacc.c:1646 */ 3988 4029 break; 3989 4030 3990 - case 238: 3991 - #line 714 "parser.y" /* yacc.c:1646 */ 4031 + case 240: 4032 + #line 737 "parser.y" /* yacc.c:1646 */ 3992 4033 { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); } 3993 - #line 3994 "parser.tab.c" /* yacc.c:1646 */ 4034 + #line 4035 "parser.tab.c" /* yacc.c:1646 */ 3994 4035 break; 3995 4036 3996 - case 239: 3997 - #line 717 "parser.y" /* yacc.c:1646 */ 4037 + case 241: 4038 + #line 740 "parser.y" /* yacc.c:1646 */ 3998 4039 { (yyval.expr) = (yyvsp[0].expr); 3999 4040 if (!(yyval.expr)->is_const) 4000 4041 error_loc("expression is not an integer constant\n"); 4001 4042 } 4002 - #line 4003 "parser.tab.c" /* yacc.c:1646 */ 4043 + #line 4044 "parser.tab.c" /* yacc.c:1646 */ 4003 4044 break; 4004 4045 4005 - case 240: 4006 - #line 723 "parser.y" /* yacc.c:1646 */ 4046 + case 242: 4047 + #line 746 "parser.y" /* yacc.c:1646 */ 4007 4048 { (yyval.expr) = (yyvsp[0].expr); 4008 4049 if (!(yyval.expr)->is_const && (yyval.expr)->type != EXPR_STRLIT && (yyval.expr)->type != EXPR_WSTRLIT) 4009 4050 error_loc("expression is not constant\n"); 4010 4051 } 4011 - #line 4012 "parser.tab.c" /* yacc.c:1646 */ 4052 + #line 4053 "parser.tab.c" /* yacc.c:1646 */ 4012 4053 break; 4013 4054 4014 - case 241: 4015 - #line 729 "parser.y" /* yacc.c:1646 */ 4055 + case 243: 4056 + #line 752 "parser.y" /* yacc.c:1646 */ 4016 4057 { (yyval.var_list) = NULL; } 4017 - #line 4018 "parser.tab.c" /* yacc.c:1646 */ 4058 + #line 4059 "parser.tab.c" /* yacc.c:1646 */ 4018 4059 break; 4019 4060 4020 - case 242: 4021 - #line 730 "parser.y" /* yacc.c:1646 */ 4061 + case 244: 4062 + #line 753 "parser.y" /* yacc.c:1646 */ 4022 4063 { (yyval.var_list) = append_var_list((yyvsp[-1].var_list), (yyvsp[0].var_list)); } 4023 - #line 4024 "parser.tab.c" /* yacc.c:1646 */ 4064 + #line 4065 "parser.tab.c" /* yacc.c:1646 */ 4024 4065 break; 4025 4066 4026 - case 243: 4027 - #line 734 "parser.y" /* yacc.c:1646 */ 4067 + case 245: 4068 + #line 757 "parser.y" /* yacc.c:1646 */ 4028 4069 { const char *first = LIST_ENTRY(list_head((yyvsp[-1].declarator_list)), declarator_t, entry)->var->name; 4029 4070 check_field_attrs(first, (yyvsp[-3].attr_list)); 4030 4071 (yyval.var_list) = set_var_types((yyvsp[-3].attr_list), (yyvsp[-2].declspec), (yyvsp[-1].declarator_list)); 4031 4072 } 4032 - #line 4033 "parser.tab.c" /* yacc.c:1646 */ 4073 + #line 4074 "parser.tab.c" /* yacc.c:1646 */ 4033 4074 break; 4034 4075 4035 - case 244: 4036 - #line 738 "parser.y" /* yacc.c:1646 */ 4076 + case 246: 4077 + #line 761 "parser.y" /* yacc.c:1646 */ 4037 4078 { var_t *v = make_var(NULL); 4038 4079 v->type = (yyvsp[-1].type); v->attrs = (yyvsp[-2].attr_list); 4039 4080 (yyval.var_list) = append_var(NULL, v); 4040 4081 } 4041 - #line 4042 "parser.tab.c" /* yacc.c:1646 */ 4082 + #line 4083 "parser.tab.c" /* yacc.c:1646 */ 4042 4083 break; 4043 4084 4044 - case 245: 4045 - #line 745 "parser.y" /* yacc.c:1646 */ 4085 + case 247: 4086 + #line 768 "parser.y" /* yacc.c:1646 */ 4046 4087 { (yyval.var) = (yyvsp[-1].var); } 4047 - #line 4048 "parser.tab.c" /* yacc.c:1646 */ 4088 + #line 4089 "parser.tab.c" /* yacc.c:1646 */ 4048 4089 break; 4049 4090 4050 - case 246: 4051 - #line 746 "parser.y" /* yacc.c:1646 */ 4091 + case 248: 4092 + #line 769 "parser.y" /* yacc.c:1646 */ 4052 4093 { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[-1].attr_list); } 4053 - #line 4054 "parser.tab.c" /* yacc.c:1646 */ 4094 + #line 4095 "parser.tab.c" /* yacc.c:1646 */ 4054 4095 break; 4055 4096 4056 - case 247: 4057 - #line 749 "parser.y" /* yacc.c:1646 */ 4097 + case 249: 4098 + #line 772 "parser.y" /* yacc.c:1646 */ 4058 4099 { (yyval.var_list) = NULL; } 4059 - #line 4060 "parser.tab.c" /* yacc.c:1646 */ 4100 + #line 4101 "parser.tab.c" /* yacc.c:1646 */ 4060 4101 break; 4061 4102 4062 - case 248: 4063 - #line 750 "parser.y" /* yacc.c:1646 */ 4103 + case 250: 4104 + #line 773 "parser.y" /* yacc.c:1646 */ 4064 4105 { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); } 4065 - #line 4066 "parser.tab.c" /* yacc.c:1646 */ 4106 + #line 4107 "parser.tab.c" /* yacc.c:1646 */ 4066 4107 break; 4067 4108 4068 - case 249: 4069 - #line 754 "parser.y" /* yacc.c:1646 */ 4109 + case 251: 4110 + #line 777 "parser.y" /* yacc.c:1646 */ 4070 4111 { (yyval.var) = (yyvsp[-1].var); } 4071 - #line 4072 "parser.tab.c" /* yacc.c:1646 */ 4112 + #line 4113 "parser.tab.c" /* yacc.c:1646 */ 4072 4113 break; 4073 4114 4074 - case 250: 4075 - #line 755 "parser.y" /* yacc.c:1646 */ 4115 + case 252: 4116 + #line 778 "parser.y" /* yacc.c:1646 */ 4076 4117 { (yyval.var) = NULL; } 4077 - #line 4078 "parser.tab.c" /* yacc.c:1646 */ 4118 + #line 4119 "parser.tab.c" /* yacc.c:1646 */ 4078 4119 break; 4079 4120 4080 - case 251: 4081 - #line 758 "parser.y" /* yacc.c:1646 */ 4121 + case 253: 4122 + #line 781 "parser.y" /* yacc.c:1646 */ 4082 4123 { (yyval.var) = declare_var(check_field_attrs((yyvsp[0].declarator)->var->name, (yyvsp[-2].attr_list)), 4083 4124 (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); 4084 4125 free((yyvsp[0].declarator)); 4085 4126 } 4086 - #line 4087 "parser.tab.c" /* yacc.c:1646 */ 4127 + #line 4128 "parser.tab.c" /* yacc.c:1646 */ 4087 4128 break; 4088 4129 4089 - case 252: 4090 - #line 762 "parser.y" /* yacc.c:1646 */ 4130 + case 254: 4131 + #line 785 "parser.y" /* yacc.c:1646 */ 4091 4132 { var_t *v = make_var(NULL); 4092 4133 v->type = (yyvsp[0].type); v->attrs = (yyvsp[-1].attr_list); 4093 4134 (yyval.var) = v; 4094 4135 } 4095 - #line 4096 "parser.tab.c" /* yacc.c:1646 */ 4136 + #line 4137 "parser.tab.c" /* yacc.c:1646 */ 4096 4137 break; 4097 4138 4098 - case 253: 4099 - #line 768 "parser.y" /* yacc.c:1646 */ 4139 + case 255: 4140 + #line 791 "parser.y" /* yacc.c:1646 */ 4100 4141 { (yyval.var) = (yyvsp[0].var); 4101 4142 if (type_get_type((yyval.var)->type) != TYPE_FUNCTION) 4102 4143 error_loc("only methods may be declared inside the methods section of a dispinterface\n"); 4103 4144 check_function_attrs((yyval.var)->name, (yyval.var)->attrs); 4104 4145 } 4105 - #line 4106 "parser.tab.c" /* yacc.c:1646 */ 4146 + #line 4147 "parser.tab.c" /* yacc.c:1646 */ 4106 4147 break; 4107 4148 4108 - case 254: 4109 - #line 777 "parser.y" /* yacc.c:1646 */ 4149 + case 256: 4150 + #line 800 "parser.y" /* yacc.c:1646 */ 4110 4151 { (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); 4111 4152 free((yyvsp[0].declarator)); 4112 4153 } 4113 - #line 4114 "parser.tab.c" /* yacc.c:1646 */ 4154 + #line 4155 "parser.tab.c" /* yacc.c:1646 */ 4114 4155 break; 4115 4156 4116 - case 255: 4117 - #line 780 "parser.y" /* yacc.c:1646 */ 4157 + case 257: 4158 + #line 803 "parser.y" /* yacc.c:1646 */ 4118 4159 { (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE); 4119 4160 free((yyvsp[0].declarator)); 4120 4161 } 4121 - #line 4122 "parser.tab.c" /* yacc.c:1646 */ 4162 + #line 4163 "parser.tab.c" /* yacc.c:1646 */ 4122 4163 break; 4123 4164 4124 - case 256: 4125 - #line 785 "parser.y" /* yacc.c:1646 */ 4165 + case 258: 4166 + #line 808 "parser.y" /* yacc.c:1646 */ 4126 4167 { (yyval.var) = NULL; } 4127 - #line 4128 "parser.tab.c" /* yacc.c:1646 */ 4168 + #line 4169 "parser.tab.c" /* yacc.c:1646 */ 4128 4169 break; 4129 4170 4130 - case 258: 4131 - #line 789 "parser.y" /* yacc.c:1646 */ 4171 + case 260: 4172 + #line 812 "parser.y" /* yacc.c:1646 */ 4132 4173 { (yyval.str) = NULL; } 4133 - #line 4134 "parser.tab.c" /* yacc.c:1646 */ 4174 + #line 4175 "parser.tab.c" /* yacc.c:1646 */ 4134 4175 break; 4135 4176 4136 - case 259: 4137 - #line 790 "parser.y" /* yacc.c:1646 */ 4177 + case 261: 4178 + #line 813 "parser.y" /* yacc.c:1646 */ 4138 4179 { (yyval.str) = (yyvsp[0].str); } 4139 - #line 4140 "parser.tab.c" /* yacc.c:1646 */ 4180 + #line 4181 "parser.tab.c" /* yacc.c:1646 */ 4140 4181 break; 4141 4182 4142 - case 260: 4143 - #line 791 "parser.y" /* yacc.c:1646 */ 4183 + case 262: 4184 + #line 814 "parser.y" /* yacc.c:1646 */ 4144 4185 { (yyval.str) = (yyvsp[0].str); } 4145 - #line 4146 "parser.tab.c" /* yacc.c:1646 */ 4186 + #line 4187 "parser.tab.c" /* yacc.c:1646 */ 4146 4187 break; 4147 4188 4148 - case 261: 4149 - #line 794 "parser.y" /* yacc.c:1646 */ 4189 + case 263: 4190 + #line 817 "parser.y" /* yacc.c:1646 */ 4150 4191 { (yyval.var) = make_var((yyvsp[0].str)); } 4151 - #line 4152 "parser.tab.c" /* yacc.c:1646 */ 4192 + #line 4193 "parser.tab.c" /* yacc.c:1646 */ 4152 4193 break; 4153 4194 4154 - case 262: 4155 - #line 796 "parser.y" /* yacc.c:1646 */ 4195 + case 264: 4196 + #line 819 "parser.y" /* yacc.c:1646 */ 4156 4197 { (yyval.var) = make_var((yyvsp[0].str)); } 4157 - #line 4158 "parser.tab.c" /* yacc.c:1646 */ 4198 + #line 4199 "parser.tab.c" /* yacc.c:1646 */ 4158 4199 break; 4159 4200 4160 - case 263: 4161 - #line 799 "parser.y" /* yacc.c:1646 */ 4201 + case 265: 4202 + #line 822 "parser.y" /* yacc.c:1646 */ 4162 4203 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4163 - #line 4164 "parser.tab.c" /* yacc.c:1646 */ 4204 + #line 4205 "parser.tab.c" /* yacc.c:1646 */ 4164 4205 break; 4165 4206 4166 - case 264: 4167 - #line 800 "parser.y" /* yacc.c:1646 */ 4207 + case 266: 4208 + #line 823 "parser.y" /* yacc.c:1646 */ 4168 4209 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4169 - #line 4170 "parser.tab.c" /* yacc.c:1646 */ 4210 + #line 4211 "parser.tab.c" /* yacc.c:1646 */ 4170 4211 break; 4171 4212 4172 - case 266: 4173 - #line 802 "parser.y" /* yacc.c:1646 */ 4213 + case 268: 4214 + #line 825 "parser.y" /* yacc.c:1646 */ 4174 4215 { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), -1); } 4175 - #line 4176 "parser.tab.c" /* yacc.c:1646 */ 4216 + #line 4217 "parser.tab.c" /* yacc.c:1646 */ 4176 4217 break; 4177 4218 4178 - case 267: 4179 - #line 803 "parser.y" /* yacc.c:1646 */ 4219 + case 269: 4220 + #line 826 "parser.y" /* yacc.c:1646 */ 4180 4221 { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), 1); } 4181 - #line 4182 "parser.tab.c" /* yacc.c:1646 */ 4222 + #line 4223 "parser.tab.c" /* yacc.c:1646 */ 4182 4223 break; 4183 4224 4184 - case 268: 4185 - #line 804 "parser.y" /* yacc.c:1646 */ 4225 + case 270: 4226 + #line 827 "parser.y" /* yacc.c:1646 */ 4186 4227 { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); } 4187 - #line 4188 "parser.tab.c" /* yacc.c:1646 */ 4228 + #line 4229 "parser.tab.c" /* yacc.c:1646 */ 4188 4229 break; 4189 4230 4190 - case 269: 4191 - #line 805 "parser.y" /* yacc.c:1646 */ 4231 + case 271: 4232 + #line 828 "parser.y" /* yacc.c:1646 */ 4192 4233 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4193 - #line 4194 "parser.tab.c" /* yacc.c:1646 */ 4234 + #line 4235 "parser.tab.c" /* yacc.c:1646 */ 4194 4235 break; 4195 4236 4196 - case 270: 4197 - #line 806 "parser.y" /* yacc.c:1646 */ 4237 + case 272: 4238 + #line 829 "parser.y" /* yacc.c:1646 */ 4198 4239 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4199 - #line 4200 "parser.tab.c" /* yacc.c:1646 */ 4240 + #line 4241 "parser.tab.c" /* yacc.c:1646 */ 4200 4241 break; 4201 4242 4202 - case 271: 4203 - #line 807 "parser.y" /* yacc.c:1646 */ 4243 + case 273: 4244 + #line 830 "parser.y" /* yacc.c:1646 */ 4204 4245 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4205 - #line 4206 "parser.tab.c" /* yacc.c:1646 */ 4246 + #line 4247 "parser.tab.c" /* yacc.c:1646 */ 4206 4247 break; 4207 4248 4208 - case 272: 4209 - #line 808 "parser.y" /* yacc.c:1646 */ 4249 + case 274: 4250 + #line 831 "parser.y" /* yacc.c:1646 */ 4210 4251 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4211 - #line 4212 "parser.tab.c" /* yacc.c:1646 */ 4252 + #line 4253 "parser.tab.c" /* yacc.c:1646 */ 4212 4253 break; 4213 4254 4214 - case 273: 4215 - #line 809 "parser.y" /* yacc.c:1646 */ 4255 + case 275: 4256 + #line 832 "parser.y" /* yacc.c:1646 */ 4216 4257 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4217 - #line 4218 "parser.tab.c" /* yacc.c:1646 */ 4258 + #line 4259 "parser.tab.c" /* yacc.c:1646 */ 4218 4259 break; 4219 4260 4220 - case 276: 4221 - #line 816 "parser.y" /* yacc.c:1646 */ 4261 + case 278: 4262 + #line 839 "parser.y" /* yacc.c:1646 */ 4222 4263 { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); } 4223 - #line 4224 "parser.tab.c" /* yacc.c:1646 */ 4264 + #line 4265 "parser.tab.c" /* yacc.c:1646 */ 4224 4265 break; 4225 4266 4226 - case 277: 4227 - #line 817 "parser.y" /* yacc.c:1646 */ 4267 + case 279: 4268 + #line 840 "parser.y" /* yacc.c:1646 */ 4228 4269 { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); } 4229 - #line 4230 "parser.tab.c" /* yacc.c:1646 */ 4270 + #line 4271 "parser.tab.c" /* yacc.c:1646 */ 4230 4271 break; 4231 4272 4232 - case 278: 4233 - #line 818 "parser.y" /* yacc.c:1646 */ 4273 + case 280: 4274 + #line 841 "parser.y" /* yacc.c:1646 */ 4234 4275 { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); } 4235 - #line 4236 "parser.tab.c" /* yacc.c:1646 */ 4276 + #line 4277 "parser.tab.c" /* yacc.c:1646 */ 4236 4277 break; 4237 4278 4238 - case 279: 4239 - #line 819 "parser.y" /* yacc.c:1646 */ 4240 - { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); } 4241 - #line 4242 "parser.tab.c" /* yacc.c:1646 */ 4279 + case 281: 4280 + #line 842 "parser.y" /* yacc.c:1646 */ 4281 + { (yyval.type) = type_new_int(TYPE_BASIC_LONG, 0); } 4282 + #line 4283 "parser.tab.c" /* yacc.c:1646 */ 4242 4283 break; 4243 4284 4244 - case 280: 4245 - #line 820 "parser.y" /* yacc.c:1646 */ 4285 + case 282: 4286 + #line 843 "parser.y" /* yacc.c:1646 */ 4246 4287 { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); } 4247 - #line 4248 "parser.tab.c" /* yacc.c:1646 */ 4288 + #line 4289 "parser.tab.c" /* yacc.c:1646 */ 4248 4289 break; 4249 4290 4250 - case 281: 4251 - #line 821 "parser.y" /* yacc.c:1646 */ 4291 + case 283: 4292 + #line 844 "parser.y" /* yacc.c:1646 */ 4252 4293 { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); } 4253 - #line 4254 "parser.tab.c" /* yacc.c:1646 */ 4294 + #line 4295 "parser.tab.c" /* yacc.c:1646 */ 4254 4295 break; 4255 4296 4256 - case 282: 4257 - #line 822 "parser.y" /* yacc.c:1646 */ 4297 + case 284: 4298 + #line 845 "parser.y" /* yacc.c:1646 */ 4258 4299 { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); } 4259 - #line 4260 "parser.tab.c" /* yacc.c:1646 */ 4300 + #line 4301 "parser.tab.c" /* yacc.c:1646 */ 4260 4301 break; 4261 4302 4262 - case 283: 4263 - #line 823 "parser.y" /* yacc.c:1646 */ 4303 + case 285: 4304 + #line 846 "parser.y" /* yacc.c:1646 */ 4305 + { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); } 4306 + #line 4307 "parser.tab.c" /* yacc.c:1646 */ 4307 + break; 4308 + 4309 + case 286: 4310 + #line 847 "parser.y" /* yacc.c:1646 */ 4264 4311 { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); } 4265 - #line 4266 "parser.tab.c" /* yacc.c:1646 */ 4312 + #line 4313 "parser.tab.c" /* yacc.c:1646 */ 4266 4313 break; 4267 4314 4268 - case 284: 4269 - #line 826 "parser.y" /* yacc.c:1646 */ 4315 + case 287: 4316 + #line 850 "parser.y" /* yacc.c:1646 */ 4270 4317 { (yyval.type) = type_new_coclass((yyvsp[0].str)); } 4271 - #line 4272 "parser.tab.c" /* yacc.c:1646 */ 4318 + #line 4319 "parser.tab.c" /* yacc.c:1646 */ 4272 4319 break; 4273 4320 4274 - case 285: 4275 - #line 827 "parser.y" /* yacc.c:1646 */ 4321 + case 288: 4322 + #line 851 "parser.y" /* yacc.c:1646 */ 4276 4323 { (yyval.type) = find_type((yyvsp[0].str), NULL, 0); 4277 4324 if (type_get_type_detect_alias((yyval.type)) != TYPE_COCLASS) 4278 4325 error_loc("%s was not declared a coclass at %s:%d\n", 4279 4326 (yyvsp[0].str), (yyval.type)->loc_info.input_name, 4280 4327 (yyval.type)->loc_info.line_number); 4281 4328 } 4282 - #line 4283 "parser.tab.c" /* yacc.c:1646 */ 4329 + #line 4330 "parser.tab.c" /* yacc.c:1646 */ 4283 4330 break; 4284 4331 4285 - case 286: 4286 - #line 835 "parser.y" /* yacc.c:1646 */ 4332 + case 289: 4333 + #line 859 "parser.y" /* yacc.c:1646 */ 4287 4334 { (yyval.type) = (yyvsp[0].type); 4288 4335 check_def((yyval.type)); 4289 4336 (yyval.type)->attrs = check_coclass_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); 4290 4337 } 4291 - #line 4292 "parser.tab.c" /* yacc.c:1646 */ 4338 + #line 4339 "parser.tab.c" /* yacc.c:1646 */ 4292 4339 break; 4293 4340 4294 - case 287: 4295 - #line 842 "parser.y" /* yacc.c:1646 */ 4341 + case 290: 4342 + #line 866 "parser.y" /* yacc.c:1646 */ 4296 4343 { (yyval.type) = type_coclass_define((yyvsp[-4].type), (yyvsp[-2].ifref_list)); } 4297 - #line 4298 "parser.tab.c" /* yacc.c:1646 */ 4344 + #line 4345 "parser.tab.c" /* yacc.c:1646 */ 4298 4345 break; 4299 4346 4300 - case 288: 4301 - #line 845 "parser.y" /* yacc.c:1646 */ 4347 + case 291: 4348 + #line 869 "parser.y" /* yacc.c:1646 */ 4302 4349 { (yyval.str) = (yyvsp[0].str); } 4303 - #line 4304 "parser.tab.c" /* yacc.c:1646 */ 4350 + #line 4351 "parser.tab.c" /* yacc.c:1646 */ 4304 4351 break; 4305 4352 4306 - case 289: 4307 - #line 848 "parser.y" /* yacc.c:1646 */ 4353 + case 292: 4354 + #line 872 "parser.y" /* yacc.c:1646 */ 4308 4355 { (yyval.ifref_list) = NULL; } 4309 - #line 4310 "parser.tab.c" /* yacc.c:1646 */ 4356 + #line 4357 "parser.tab.c" /* yacc.c:1646 */ 4310 4357 break; 4311 4358 4312 - case 290: 4313 - #line 849 "parser.y" /* yacc.c:1646 */ 4359 + case 293: 4360 + #line 873 "parser.y" /* yacc.c:1646 */ 4314 4361 { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), (yyvsp[0].ifref) ); } 4315 - #line 4316 "parser.tab.c" /* yacc.c:1646 */ 4362 + #line 4363 "parser.tab.c" /* yacc.c:1646 */ 4316 4363 break; 4317 4364 4318 - case 291: 4319 - #line 853 "parser.y" /* yacc.c:1646 */ 4365 + case 294: 4366 + #line 877 "parser.y" /* yacc.c:1646 */ 4320 4367 { (yyval.ifref) = make_ifref((yyvsp[0].type)); (yyval.ifref)->attrs = (yyvsp[-1].attr_list); } 4321 - #line 4322 "parser.tab.c" /* yacc.c:1646 */ 4368 + #line 4369 "parser.tab.c" /* yacc.c:1646 */ 4322 4369 break; 4323 4370 4324 - case 292: 4325 - #line 856 "parser.y" /* yacc.c:1646 */ 4371 + case 295: 4372 + #line 880 "parser.y" /* yacc.c:1646 */ 4326 4373 { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } 4327 - #line 4328 "parser.tab.c" /* yacc.c:1646 */ 4374 + #line 4375 "parser.tab.c" /* yacc.c:1646 */ 4328 4375 break; 4329 4376 4330 - case 293: 4331 - #line 857 "parser.y" /* yacc.c:1646 */ 4377 + case 296: 4378 + #line 881 "parser.y" /* yacc.c:1646 */ 4332 4379 { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } 4333 - #line 4334 "parser.tab.c" /* yacc.c:1646 */ 4380 + #line 4381 "parser.tab.c" /* yacc.c:1646 */ 4334 4381 break; 4335 4382 4336 - case 294: 4337 - #line 860 "parser.y" /* yacc.c:1646 */ 4383 + case 297: 4384 + #line 884 "parser.y" /* yacc.c:1646 */ 4338 4385 { attr_t *attrs; 4339 4386 (yyval.type) = (yyvsp[0].type); 4340 4387 check_def((yyval.type)); ··· 4342 4389 (yyval.type)->attrs = append_attr( check_dispiface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)), attrs ); 4343 4390 (yyval.type)->defined = TRUE; 4344 4391 } 4345 - #line 4346 "parser.tab.c" /* yacc.c:1646 */ 4392 + #line 4393 "parser.tab.c" /* yacc.c:1646 */ 4346 4393 break; 4347 4394 4348 - case 295: 4349 - #line 869 "parser.y" /* yacc.c:1646 */ 4395 + case 298: 4396 + #line 893 "parser.y" /* yacc.c:1646 */ 4350 4397 { (yyval.var_list) = NULL; } 4351 - #line 4352 "parser.tab.c" /* yacc.c:1646 */ 4398 + #line 4399 "parser.tab.c" /* yacc.c:1646 */ 4352 4399 break; 4353 4400 4354 - case 296: 4355 - #line 870 "parser.y" /* yacc.c:1646 */ 4401 + case 299: 4402 + #line 894 "parser.y" /* yacc.c:1646 */ 4356 4403 { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); } 4357 - #line 4358 "parser.tab.c" /* yacc.c:1646 */ 4404 + #line 4405 "parser.tab.c" /* yacc.c:1646 */ 4358 4405 break; 4359 4406 4360 - case 297: 4361 - #line 873 "parser.y" /* yacc.c:1646 */ 4407 + case 300: 4408 + #line 897 "parser.y" /* yacc.c:1646 */ 4362 4409 { (yyval.var_list) = NULL; } 4363 - #line 4364 "parser.tab.c" /* yacc.c:1646 */ 4410 + #line 4411 "parser.tab.c" /* yacc.c:1646 */ 4364 4411 break; 4365 4412 4366 - case 298: 4367 - #line 874 "parser.y" /* yacc.c:1646 */ 4413 + case 301: 4414 + #line 898 "parser.y" /* yacc.c:1646 */ 4368 4415 { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); } 4369 - #line 4370 "parser.tab.c" /* yacc.c:1646 */ 4416 + #line 4417 "parser.tab.c" /* yacc.c:1646 */ 4370 4417 break; 4371 4418 4372 - case 299: 4373 - #line 880 "parser.y" /* yacc.c:1646 */ 4419 + case 302: 4420 + #line 904 "parser.y" /* yacc.c:1646 */ 4374 4421 { (yyval.type) = (yyvsp[-4].type); 4375 4422 type_dispinterface_define((yyval.type), (yyvsp[-2].var_list), (yyvsp[-1].var_list)); 4376 4423 } 4377 - #line 4378 "parser.tab.c" /* yacc.c:1646 */ 4424 + #line 4425 "parser.tab.c" /* yacc.c:1646 */ 4378 4425 break; 4379 4426 4380 - case 300: 4381 - #line 884 "parser.y" /* yacc.c:1646 */ 4427 + case 303: 4428 + #line 908 "parser.y" /* yacc.c:1646 */ 4382 4429 { (yyval.type) = (yyvsp[-4].type); 4383 4430 type_dispinterface_define_from_iface((yyval.type), (yyvsp[-2].type)); 4384 4431 } 4385 - #line 4386 "parser.tab.c" /* yacc.c:1646 */ 4432 + #line 4433 "parser.tab.c" /* yacc.c:1646 */ 4386 4433 break; 4387 4434 4388 - case 301: 4389 - #line 889 "parser.y" /* yacc.c:1646 */ 4435 + case 304: 4436 + #line 913 "parser.y" /* yacc.c:1646 */ 4390 4437 { (yyval.type) = NULL; } 4391 - #line 4392 "parser.tab.c" /* yacc.c:1646 */ 4438 + #line 4439 "parser.tab.c" /* yacc.c:1646 */ 4392 4439 break; 4393 4440 4394 - case 302: 4395 - #line 890 "parser.y" /* yacc.c:1646 */ 4441 + case 305: 4442 + #line 914 "parser.y" /* yacc.c:1646 */ 4396 4443 { (yyval.type) = find_type_or_error2((yyvsp[0].str), 0); } 4397 - #line 4398 "parser.tab.c" /* yacc.c:1646 */ 4444 + #line 4445 "parser.tab.c" /* yacc.c:1646 */ 4398 4445 break; 4399 4446 4400 - case 303: 4401 - #line 893 "parser.y" /* yacc.c:1646 */ 4447 + case 306: 4448 + #line 917 "parser.y" /* yacc.c:1646 */ 4402 4449 { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } 4403 - #line 4404 "parser.tab.c" /* yacc.c:1646 */ 4450 + #line 4451 "parser.tab.c" /* yacc.c:1646 */ 4404 4451 break; 4405 4452 4406 - case 304: 4407 - #line 894 "parser.y" /* yacc.c:1646 */ 4453 + case 307: 4454 + #line 918 "parser.y" /* yacc.c:1646 */ 4408 4455 { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); } 4409 - #line 4410 "parser.tab.c" /* yacc.c:1646 */ 4456 + #line 4457 "parser.tab.c" /* yacc.c:1646 */ 4410 4457 break; 4411 4458 4412 - case 305: 4413 - #line 897 "parser.y" /* yacc.c:1646 */ 4459 + case 308: 4460 + #line 921 "parser.y" /* yacc.c:1646 */ 4414 4461 { (yyval.ifinfo).interface = (yyvsp[0].type); 4415 4462 (yyval.ifinfo).old_pointer_default = pointer_default; 4416 4463 if (is_attr((yyvsp[-1].attr_list), ATTR_POINTERDEFAULT)) ··· 4419 4466 (yyvsp[0].type)->attrs = check_iface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); 4420 4467 (yyvsp[0].type)->defined = TRUE; 4421 4468 } 4422 - #line 4423 "parser.tab.c" /* yacc.c:1646 */ 4469 + #line 4470 "parser.tab.c" /* yacc.c:1646 */ 4423 4470 break; 4424 4471 4425 - case 306: 4426 - #line 908 "parser.y" /* yacc.c:1646 */ 4472 + case 309: 4473 + #line 932 "parser.y" /* yacc.c:1646 */ 4427 4474 { (yyval.type) = (yyvsp[-5].ifinfo).interface; 4428 4475 if((yyval.type) == (yyvsp[-4].type)) 4429 4476 error_loc("Interface can't inherit from itself\n"); 4430 4477 type_interface_define((yyval.type), (yyvsp[-4].type), (yyvsp[-2].stmt_list)); 4478 + check_async_uuid((yyval.type)); 4431 4479 pointer_default = (yyvsp[-5].ifinfo).old_pointer_default; 4432 4480 } 4433 - #line 4434 "parser.tab.c" /* yacc.c:1646 */ 4481 + #line 4482 "parser.tab.c" /* yacc.c:1646 */ 4434 4482 break; 4435 4483 4436 - case 307: 4437 - #line 918 "parser.y" /* yacc.c:1646 */ 4484 + case 310: 4485 + #line 943 "parser.y" /* yacc.c:1646 */ 4438 4486 { (yyval.type) = (yyvsp[-7].ifinfo).interface; 4439 4487 type_interface_define((yyval.type), find_type_or_error2((yyvsp[-5].str), 0), (yyvsp[-2].stmt_list)); 4440 4488 pointer_default = (yyvsp[-7].ifinfo).old_pointer_default; 4441 4489 } 4442 - #line 4443 "parser.tab.c" /* yacc.c:1646 */ 4490 + #line 4491 "parser.tab.c" /* yacc.c:1646 */ 4443 4491 break; 4444 4492 4445 - case 308: 4446 - #line 922 "parser.y" /* yacc.c:1646 */ 4493 + case 311: 4494 + #line 947 "parser.y" /* yacc.c:1646 */ 4447 4495 { (yyval.type) = (yyvsp[-1].type); } 4448 - #line 4449 "parser.tab.c" /* yacc.c:1646 */ 4496 + #line 4497 "parser.tab.c" /* yacc.c:1646 */ 4449 4497 break; 4450 4498 4451 - case 309: 4452 - #line 926 "parser.y" /* yacc.c:1646 */ 4499 + case 312: 4500 + #line 951 "parser.y" /* yacc.c:1646 */ 4453 4501 { (yyval.type) = (yyvsp[-1].type); } 4454 - #line 4455 "parser.tab.c" /* yacc.c:1646 */ 4502 + #line 4503 "parser.tab.c" /* yacc.c:1646 */ 4455 4503 break; 4456 4504 4457 - case 310: 4458 - #line 927 "parser.y" /* yacc.c:1646 */ 4505 + case 313: 4506 + #line 952 "parser.y" /* yacc.c:1646 */ 4459 4507 { (yyval.type) = (yyvsp[-1].type); } 4460 - #line 4461 "parser.tab.c" /* yacc.c:1646 */ 4508 + #line 4509 "parser.tab.c" /* yacc.c:1646 */ 4461 4509 break; 4462 4510 4463 - case 311: 4464 - #line 930 "parser.y" /* yacc.c:1646 */ 4511 + case 314: 4512 + #line 955 "parser.y" /* yacc.c:1646 */ 4465 4513 { (yyval.type) = type_new_module((yyvsp[0].str)); } 4466 - #line 4467 "parser.tab.c" /* yacc.c:1646 */ 4514 + #line 4515 "parser.tab.c" /* yacc.c:1646 */ 4467 4515 break; 4468 4516 4469 - case 312: 4470 - #line 931 "parser.y" /* yacc.c:1646 */ 4517 + case 315: 4518 + #line 956 "parser.y" /* yacc.c:1646 */ 4471 4519 { (yyval.type) = type_new_module((yyvsp[0].str)); } 4472 - #line 4473 "parser.tab.c" /* yacc.c:1646 */ 4520 + #line 4521 "parser.tab.c" /* yacc.c:1646 */ 4473 4521 break; 4474 4522 4475 - case 313: 4476 - #line 934 "parser.y" /* yacc.c:1646 */ 4523 + case 316: 4524 + #line 959 "parser.y" /* yacc.c:1646 */ 4477 4525 { (yyval.type) = (yyvsp[0].type); 4478 4526 (yyval.type)->attrs = check_module_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)); 4479 4527 } 4480 - #line 4481 "parser.tab.c" /* yacc.c:1646 */ 4528 + #line 4529 "parser.tab.c" /* yacc.c:1646 */ 4481 4529 break; 4482 4530 4483 - case 314: 4484 - #line 940 "parser.y" /* yacc.c:1646 */ 4531 + case 317: 4532 + #line 965 "parser.y" /* yacc.c:1646 */ 4485 4533 { (yyval.type) = (yyvsp[-4].type); 4486 4534 type_module_define((yyval.type), (yyvsp[-2].stmt_list)); 4487 4535 } 4488 - #line 4489 "parser.tab.c" /* yacc.c:1646 */ 4536 + #line 4537 "parser.tab.c" /* yacc.c:1646 */ 4489 4537 break; 4490 4538 4491 - case 315: 4492 - #line 946 "parser.y" /* yacc.c:1646 */ 4539 + case 318: 4540 + #line 971 "parser.y" /* yacc.c:1646 */ 4493 4541 { (yyval.stgclass) = STG_EXTERN; } 4494 - #line 4495 "parser.tab.c" /* yacc.c:1646 */ 4542 + #line 4543 "parser.tab.c" /* yacc.c:1646 */ 4495 4543 break; 4496 4544 4497 - case 316: 4498 - #line 947 "parser.y" /* yacc.c:1646 */ 4545 + case 319: 4546 + #line 972 "parser.y" /* yacc.c:1646 */ 4499 4547 { (yyval.stgclass) = STG_STATIC; } 4500 - #line 4501 "parser.tab.c" /* yacc.c:1646 */ 4548 + #line 4549 "parser.tab.c" /* yacc.c:1646 */ 4501 4549 break; 4502 4550 4503 - case 317: 4504 - #line 948 "parser.y" /* yacc.c:1646 */ 4551 + case 320: 4552 + #line 973 "parser.y" /* yacc.c:1646 */ 4505 4553 { (yyval.stgclass) = STG_REGISTER; } 4506 - #line 4507 "parser.tab.c" /* yacc.c:1646 */ 4554 + #line 4555 "parser.tab.c" /* yacc.c:1646 */ 4507 4555 break; 4508 4556 4509 - case 318: 4510 - #line 952 "parser.y" /* yacc.c:1646 */ 4557 + case 321: 4558 + #line 977 "parser.y" /* yacc.c:1646 */ 4511 4559 { (yyval.attr) = make_attr(ATTR_INLINE); } 4512 - #line 4513 "parser.tab.c" /* yacc.c:1646 */ 4560 + #line 4561 "parser.tab.c" /* yacc.c:1646 */ 4513 4561 break; 4514 4562 4515 - case 319: 4516 - #line 956 "parser.y" /* yacc.c:1646 */ 4563 + case 322: 4564 + #line 981 "parser.y" /* yacc.c:1646 */ 4517 4565 { (yyval.attr) = make_attr(ATTR_CONST); } 4518 - #line 4519 "parser.tab.c" /* yacc.c:1646 */ 4566 + #line 4567 "parser.tab.c" /* yacc.c:1646 */ 4519 4567 break; 4520 4568 4521 - case 320: 4522 - #line 959 "parser.y" /* yacc.c:1646 */ 4569 + case 323: 4570 + #line 984 "parser.y" /* yacc.c:1646 */ 4523 4571 { (yyval.attr_list) = NULL; } 4524 - #line 4525 "parser.tab.c" /* yacc.c:1646 */ 4572 + #line 4573 "parser.tab.c" /* yacc.c:1646 */ 4525 4573 break; 4526 4574 4527 - case 321: 4528 - #line 960 "parser.y" /* yacc.c:1646 */ 4575 + case 324: 4576 + #line 985 "parser.y" /* yacc.c:1646 */ 4529 4577 { (yyval.attr_list) = append_attr((yyvsp[-1].attr_list), (yyvsp[0].attr)); } 4530 - #line 4531 "parser.tab.c" /* yacc.c:1646 */ 4578 + #line 4579 "parser.tab.c" /* yacc.c:1646 */ 4531 4579 break; 4532 4580 4533 - case 322: 4534 - #line 963 "parser.y" /* yacc.c:1646 */ 4581 + case 325: 4582 + #line 988 "parser.y" /* yacc.c:1646 */ 4535 4583 { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[0].declspec), NULL, NULL, STG_NONE); } 4536 - #line 4537 "parser.tab.c" /* yacc.c:1646 */ 4584 + #line 4585 "parser.tab.c" /* yacc.c:1646 */ 4537 4585 break; 4538 4586 4539 - case 323: 4540 - #line 965 "parser.y" /* yacc.c:1646 */ 4587 + case 326: 4588 + #line 990 "parser.y" /* yacc.c:1646 */ 4541 4589 { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[-2].declspec), (yyvsp[0].declspec), NULL, STG_NONE); } 4542 - #line 4543 "parser.tab.c" /* yacc.c:1646 */ 4590 + #line 4591 "parser.tab.c" /* yacc.c:1646 */ 4543 4591 break; 4544 4592 4545 - case 324: 4546 - #line 968 "parser.y" /* yacc.c:1646 */ 4593 + case 327: 4594 + #line 993 "parser.y" /* yacc.c:1646 */ 4547 4595 { (yyval.declspec) = NULL; } 4548 - #line 4549 "parser.tab.c" /* yacc.c:1646 */ 4596 + #line 4597 "parser.tab.c" /* yacc.c:1646 */ 4549 4597 break; 4550 4598 4551 - case 326: 4552 - #line 973 "parser.y" /* yacc.c:1646 */ 4599 + case 329: 4600 + #line 998 "parser.y" /* yacc.c:1646 */ 4553 4601 { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); } 4554 - #line 4555 "parser.tab.c" /* yacc.c:1646 */ 4602 + #line 4603 "parser.tab.c" /* yacc.c:1646 */ 4555 4603 break; 4556 4604 4557 - case 327: 4558 - #line 974 "parser.y" /* yacc.c:1646 */ 4605 + case 330: 4606 + #line 999 "parser.y" /* yacc.c:1646 */ 4559 4607 { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); } 4560 - #line 4561 "parser.tab.c" /* yacc.c:1646 */ 4608 + #line 4609 "parser.tab.c" /* yacc.c:1646 */ 4561 4609 break; 4562 4610 4563 - case 328: 4564 - #line 975 "parser.y" /* yacc.c:1646 */ 4611 + case 331: 4612 + #line 1000 "parser.y" /* yacc.c:1646 */ 4565 4613 { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, NULL, (yyvsp[-1].stgclass)); } 4566 - #line 4567 "parser.tab.c" /* yacc.c:1646 */ 4614 + #line 4615 "parser.tab.c" /* yacc.c:1646 */ 4567 4615 break; 4568 4616 4569 - case 329: 4570 - #line 980 "parser.y" /* yacc.c:1646 */ 4571 - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4572 - #line 4573 "parser.tab.c" /* yacc.c:1646 */ 4617 + case 332: 4618 + #line 1005 "parser.y" /* yacc.c:1646 */ 4619 + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4620 + #line 4621 "parser.tab.c" /* yacc.c:1646 */ 4573 4621 break; 4574 4622 4575 - case 330: 4576 - #line 981 "parser.y" /* yacc.c:1646 */ 4623 + case 333: 4624 + #line 1006 "parser.y" /* yacc.c:1646 */ 4577 4625 { (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))); 4578 4626 else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } 4579 - #line 4580 "parser.tab.c" /* yacc.c:1646 */ 4627 + #line 4628 "parser.tab.c" /* yacc.c:1646 */ 4580 4628 break; 4581 4629 4582 - case 332: 4583 - #line 987 "parser.y" /* yacc.c:1646 */ 4630 + case 335: 4631 + #line 1012 "parser.y" /* yacc.c:1646 */ 4584 4632 { (yyval.declarator) = make_declarator((yyvsp[0].var)); } 4585 - #line 4586 "parser.tab.c" /* yacc.c:1646 */ 4633 + #line 4634 "parser.tab.c" /* yacc.c:1646 */ 4586 4634 break; 4587 4635 4588 - case 333: 4589 - #line 988 "parser.y" /* yacc.c:1646 */ 4636 + case 336: 4637 + #line 1013 "parser.y" /* yacc.c:1646 */ 4590 4638 { (yyval.declarator) = (yyvsp[-1].declarator); } 4591 - #line 4592 "parser.tab.c" /* yacc.c:1646 */ 4639 + #line 4640 "parser.tab.c" /* yacc.c:1646 */ 4592 4640 break; 4593 4641 4594 - case 334: 4595 - #line 989 "parser.y" /* yacc.c:1646 */ 4596 - { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } 4597 - #line 4598 "parser.tab.c" /* yacc.c:1646 */ 4642 + case 337: 4643 + #line 1014 "parser.y" /* yacc.c:1646 */ 4644 + { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } 4645 + #line 4646 "parser.tab.c" /* yacc.c:1646 */ 4598 4646 break; 4599 4647 4600 - case 335: 4601 - #line 990 "parser.y" /* yacc.c:1646 */ 4648 + case 338: 4649 + #line 1015 "parser.y" /* yacc.c:1646 */ 4602 4650 { (yyval.declarator) = (yyvsp[-3].declarator); 4603 - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4651 + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4604 4652 (yyval.declarator)->type = NULL; 4605 4653 } 4606 - #line 4607 "parser.tab.c" /* yacc.c:1646 */ 4654 + #line 4655 "parser.tab.c" /* yacc.c:1646 */ 4607 4655 break; 4608 4656 4609 - case 336: 4610 - #line 999 "parser.y" /* yacc.c:1646 */ 4611 - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4612 - #line 4613 "parser.tab.c" /* yacc.c:1646 */ 4657 + case 339: 4658 + #line 1024 "parser.y" /* yacc.c:1646 */ 4659 + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4660 + #line 4661 "parser.tab.c" /* yacc.c:1646 */ 4613 4661 break; 4614 4662 4615 - case 337: 4616 - #line 1000 "parser.y" /* yacc.c:1646 */ 4663 + case 340: 4664 + #line 1025 "parser.y" /* yacc.c:1646 */ 4617 4665 { (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))); 4618 4666 else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } 4619 - #line 4620 "parser.tab.c" /* yacc.c:1646 */ 4667 + #line 4668 "parser.tab.c" /* yacc.c:1646 */ 4620 4668 break; 4621 4669 4622 - case 339: 4623 - #line 1008 "parser.y" /* yacc.c:1646 */ 4624 - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4625 - #line 4626 "parser.tab.c" /* yacc.c:1646 */ 4670 + case 342: 4671 + #line 1033 "parser.y" /* yacc.c:1646 */ 4672 + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4673 + #line 4674 "parser.tab.c" /* yacc.c:1646 */ 4626 4674 break; 4627 4675 4628 - case 340: 4629 - #line 1009 "parser.y" /* yacc.c:1646 */ 4676 + case 343: 4677 + #line 1034 "parser.y" /* yacc.c:1646 */ 4630 4678 { (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))); 4631 4679 else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } 4632 - #line 4633 "parser.tab.c" /* yacc.c:1646 */ 4680 + #line 4681 "parser.tab.c" /* yacc.c:1646 */ 4633 4681 break; 4634 4682 4635 - case 341: 4636 - #line 1014 "parser.y" /* yacc.c:1646 */ 4683 + case 344: 4684 + #line 1039 "parser.y" /* yacc.c:1646 */ 4637 4685 { (yyval.declarator) = make_declarator(NULL); } 4638 - #line 4639 "parser.tab.c" /* yacc.c:1646 */ 4686 + #line 4687 "parser.tab.c" /* yacc.c:1646 */ 4639 4687 break; 4640 4688 4641 - case 343: 4642 - #line 1020 "parser.y" /* yacc.c:1646 */ 4689 + case 346: 4690 + #line 1045 "parser.y" /* yacc.c:1646 */ 4643 4691 { (yyval.declarator) = (yyvsp[-1].declarator); } 4644 - #line 4645 "parser.tab.c" /* yacc.c:1646 */ 4692 + #line 4693 "parser.tab.c" /* yacc.c:1646 */ 4645 4693 break; 4646 4694 4647 - case 344: 4648 - #line 1021 "parser.y" /* yacc.c:1646 */ 4649 - { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } 4650 - #line 4651 "parser.tab.c" /* yacc.c:1646 */ 4695 + case 347: 4696 + #line 1046 "parser.y" /* yacc.c:1646 */ 4697 + { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } 4698 + #line 4699 "parser.tab.c" /* yacc.c:1646 */ 4651 4699 break; 4652 4700 4653 - case 345: 4654 - #line 1022 "parser.y" /* yacc.c:1646 */ 4655 - { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } 4656 - #line 4657 "parser.tab.c" /* yacc.c:1646 */ 4701 + case 348: 4702 + #line 1047 "parser.y" /* yacc.c:1646 */ 4703 + { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } 4704 + #line 4705 "parser.tab.c" /* yacc.c:1646 */ 4657 4705 break; 4658 4706 4659 - case 346: 4660 - #line 1024 "parser.y" /* yacc.c:1646 */ 4707 + case 349: 4708 + #line 1049 "parser.y" /* yacc.c:1646 */ 4661 4709 { (yyval.declarator) = make_declarator(NULL); 4662 - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4710 + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4663 4711 (yyval.declarator)->type = NULL; 4664 4712 } 4665 - #line 4666 "parser.tab.c" /* yacc.c:1646 */ 4713 + #line 4714 "parser.tab.c" /* yacc.c:1646 */ 4666 4714 break; 4667 4715 4668 - case 347: 4669 - #line 1029 "parser.y" /* yacc.c:1646 */ 4716 + case 350: 4717 + #line 1054 "parser.y" /* yacc.c:1646 */ 4670 4718 { (yyval.declarator) = (yyvsp[-3].declarator); 4671 - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4719 + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4672 4720 (yyval.declarator)->type = NULL; 4673 4721 } 4674 - #line 4675 "parser.tab.c" /* yacc.c:1646 */ 4722 + #line 4723 "parser.tab.c" /* yacc.c:1646 */ 4675 4723 break; 4676 4724 4677 - case 348: 4678 - #line 1038 "parser.y" /* yacc.c:1646 */ 4679 - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4680 - #line 4681 "parser.tab.c" /* yacc.c:1646 */ 4725 + case 351: 4726 + #line 1063 "parser.y" /* yacc.c:1646 */ 4727 + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4728 + #line 4729 "parser.tab.c" /* yacc.c:1646 */ 4681 4729 break; 4682 4730 4683 - case 349: 4684 - #line 1039 "parser.y" /* yacc.c:1646 */ 4731 + case 352: 4732 + #line 1064 "parser.y" /* yacc.c:1646 */ 4685 4733 { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } 4686 - #line 4687 "parser.tab.c" /* yacc.c:1646 */ 4734 + #line 4735 "parser.tab.c" /* yacc.c:1646 */ 4687 4735 break; 4688 4736 4689 - case 351: 4690 - #line 1046 "parser.y" /* yacc.c:1646 */ 4691 - { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4692 - #line 4693 "parser.tab.c" /* yacc.c:1646 */ 4737 + case 354: 4738 + #line 1071 "parser.y" /* yacc.c:1646 */ 4739 + { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); } 4740 + #line 4741 "parser.tab.c" /* yacc.c:1646 */ 4693 4741 break; 4694 4742 4695 - case 352: 4696 - #line 1047 "parser.y" /* yacc.c:1646 */ 4743 + case 355: 4744 + #line 1072 "parser.y" /* yacc.c:1646 */ 4697 4745 { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); } 4698 - #line 4699 "parser.tab.c" /* yacc.c:1646 */ 4746 + #line 4747 "parser.tab.c" /* yacc.c:1646 */ 4699 4747 break; 4700 4748 4701 - case 353: 4702 - #line 1051 "parser.y" /* yacc.c:1646 */ 4749 + case 356: 4750 + #line 1076 "parser.y" /* yacc.c:1646 */ 4703 4751 { (yyval.declarator) = make_declarator(NULL); } 4704 - #line 4705 "parser.tab.c" /* yacc.c:1646 */ 4752 + #line 4753 "parser.tab.c" /* yacc.c:1646 */ 4705 4753 break; 4706 4754 4707 - case 355: 4708 - #line 1059 "parser.y" /* yacc.c:1646 */ 4755 + case 358: 4756 + #line 1084 "parser.y" /* yacc.c:1646 */ 4709 4757 { (yyval.declarator) = make_declarator((yyvsp[0].var)); } 4710 - #line 4711 "parser.tab.c" /* yacc.c:1646 */ 4758 + #line 4759 "parser.tab.c" /* yacc.c:1646 */ 4711 4759 break; 4712 4760 4713 - case 356: 4714 - #line 1060 "parser.y" /* yacc.c:1646 */ 4761 + case 359: 4762 + #line 1085 "parser.y" /* yacc.c:1646 */ 4715 4763 { (yyval.declarator) = (yyvsp[-1].declarator); } 4716 - #line 4717 "parser.tab.c" /* yacc.c:1646 */ 4764 + #line 4765 "parser.tab.c" /* yacc.c:1646 */ 4717 4765 break; 4718 4766 4719 - case 357: 4720 - #line 1061 "parser.y" /* yacc.c:1646 */ 4721 - { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } 4722 - #line 4723 "parser.tab.c" /* yacc.c:1646 */ 4767 + case 360: 4768 + #line 1086 "parser.y" /* yacc.c:1646 */ 4769 + { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } 4770 + #line 4771 "parser.tab.c" /* yacc.c:1646 */ 4723 4771 break; 4724 4772 4725 - case 358: 4726 - #line 1062 "parser.y" /* yacc.c:1646 */ 4727 - { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); } 4728 - #line 4729 "parser.tab.c" /* yacc.c:1646 */ 4773 + case 361: 4774 + #line 1087 "parser.y" /* yacc.c:1646 */ 4775 + { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); } 4776 + #line 4777 "parser.tab.c" /* yacc.c:1646 */ 4729 4777 break; 4730 4778 4731 - case 359: 4732 - #line 1064 "parser.y" /* yacc.c:1646 */ 4779 + case 362: 4780 + #line 1089 "parser.y" /* yacc.c:1646 */ 4733 4781 { (yyval.declarator) = make_declarator(NULL); 4734 - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4782 + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4735 4783 (yyval.declarator)->type = NULL; 4736 4784 } 4737 - #line 4738 "parser.tab.c" /* yacc.c:1646 */ 4785 + #line 4786 "parser.tab.c" /* yacc.c:1646 */ 4738 4786 break; 4739 4787 4740 - case 360: 4741 - #line 1069 "parser.y" /* yacc.c:1646 */ 4788 + case 363: 4789 + #line 1094 "parser.y" /* yacc.c:1646 */ 4742 4790 { (yyval.declarator) = (yyvsp[-3].declarator); 4743 - (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4791 + (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list))); 4744 4792 (yyval.declarator)->type = NULL; 4745 4793 } 4746 - #line 4747 "parser.tab.c" /* yacc.c:1646 */ 4794 + #line 4795 "parser.tab.c" /* yacc.c:1646 */ 4747 4795 break; 4748 4796 4749 - case 361: 4750 - #line 1076 "parser.y" /* yacc.c:1646 */ 4797 + case 364: 4798 + #line 1101 "parser.y" /* yacc.c:1646 */ 4751 4799 { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); } 4752 - #line 4753 "parser.tab.c" /* yacc.c:1646 */ 4800 + #line 4801 "parser.tab.c" /* yacc.c:1646 */ 4753 4801 break; 4754 4802 4755 - case 362: 4756 - #line 1077 "parser.y" /* yacc.c:1646 */ 4803 + case 365: 4804 + #line 1102 "parser.y" /* yacc.c:1646 */ 4757 4805 { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); } 4758 - #line 4759 "parser.tab.c" /* yacc.c:1646 */ 4806 + #line 4807 "parser.tab.c" /* yacc.c:1646 */ 4759 4807 break; 4760 4808 4761 - case 363: 4762 - #line 1080 "parser.y" /* yacc.c:1646 */ 4809 + case 366: 4810 + #line 1105 "parser.y" /* yacc.c:1646 */ 4763 4811 { (yyval.expr) = NULL; } 4764 - #line 4765 "parser.tab.c" /* yacc.c:1646 */ 4812 + #line 4813 "parser.tab.c" /* yacc.c:1646 */ 4765 4813 break; 4766 4814 4767 - case 364: 4768 - #line 1081 "parser.y" /* yacc.c:1646 */ 4815 + case 367: 4816 + #line 1106 "parser.y" /* yacc.c:1646 */ 4769 4817 { (yyval.expr) = (yyvsp[0].expr); } 4770 - #line 4771 "parser.tab.c" /* yacc.c:1646 */ 4818 + #line 4819 "parser.tab.c" /* yacc.c:1646 */ 4771 4819 break; 4772 4820 4773 - case 365: 4774 - #line 1084 "parser.y" /* yacc.c:1646 */ 4821 + case 368: 4822 + #line 1109 "parser.y" /* yacc.c:1646 */ 4775 4823 { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->bits = (yyvsp[0].expr); 4776 4824 if (!(yyval.declarator)->bits && !(yyval.declarator)->var->name) 4777 4825 error_loc("unnamed fields are not allowed\n"); 4778 4826 } 4779 - #line 4780 "parser.tab.c" /* yacc.c:1646 */ 4827 + #line 4828 "parser.tab.c" /* yacc.c:1646 */ 4780 4828 break; 4781 4829 4782 - case 366: 4783 - #line 1091 "parser.y" /* yacc.c:1646 */ 4830 + case 369: 4831 + #line 1116 "parser.y" /* yacc.c:1646 */ 4784 4832 { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); } 4785 - #line 4786 "parser.tab.c" /* yacc.c:1646 */ 4833 + #line 4834 "parser.tab.c" /* yacc.c:1646 */ 4786 4834 break; 4787 4835 4788 - case 367: 4789 - #line 1093 "parser.y" /* yacc.c:1646 */ 4836 + case 370: 4837 + #line 1118 "parser.y" /* yacc.c:1646 */ 4790 4838 { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); } 4791 - #line 4792 "parser.tab.c" /* yacc.c:1646 */ 4839 + #line 4840 "parser.tab.c" /* yacc.c:1646 */ 4792 4840 break; 4793 4841 4794 - case 368: 4795 - #line 1097 "parser.y" /* yacc.c:1646 */ 4842 + case 371: 4843 + #line 1122 "parser.y" /* yacc.c:1646 */ 4796 4844 { (yyval.declarator) = (yyvsp[0].declarator); } 4797 - #line 4798 "parser.tab.c" /* yacc.c:1646 */ 4845 + #line 4846 "parser.tab.c" /* yacc.c:1646 */ 4798 4846 break; 4799 4847 4800 - case 369: 4801 - #line 1098 "parser.y" /* yacc.c:1646 */ 4848 + case 372: 4849 + #line 1123 "parser.y" /* yacc.c:1646 */ 4802 4850 { (yyval.declarator) = (yyvsp[-2].declarator); (yyvsp[-2].declarator)->var->eval = (yyvsp[0].expr); } 4803 - #line 4804 "parser.tab.c" /* yacc.c:1646 */ 4851 + #line 4852 "parser.tab.c" /* yacc.c:1646 */ 4804 4852 break; 4805 4853 4806 - case 370: 4807 - #line 1102 "parser.y" /* yacc.c:1646 */ 4854 + case 373: 4855 + #line 1127 "parser.y" /* yacc.c:1646 */ 4808 4856 { (yyval.num) = THREADING_APARTMENT; } 4809 - #line 4810 "parser.tab.c" /* yacc.c:1646 */ 4857 + #line 4858 "parser.tab.c" /* yacc.c:1646 */ 4810 4858 break; 4811 4859 4812 - case 371: 4813 - #line 1103 "parser.y" /* yacc.c:1646 */ 4860 + case 374: 4861 + #line 1128 "parser.y" /* yacc.c:1646 */ 4814 4862 { (yyval.num) = THREADING_NEUTRAL; } 4815 - #line 4816 "parser.tab.c" /* yacc.c:1646 */ 4863 + #line 4864 "parser.tab.c" /* yacc.c:1646 */ 4816 4864 break; 4817 4865 4818 - case 372: 4819 - #line 1104 "parser.y" /* yacc.c:1646 */ 4866 + case 375: 4867 + #line 1129 "parser.y" /* yacc.c:1646 */ 4820 4868 { (yyval.num) = THREADING_SINGLE; } 4821 - #line 4822 "parser.tab.c" /* yacc.c:1646 */ 4869 + #line 4870 "parser.tab.c" /* yacc.c:1646 */ 4822 4870 break; 4823 4871 4824 - case 373: 4825 - #line 1105 "parser.y" /* yacc.c:1646 */ 4872 + case 376: 4873 + #line 1130 "parser.y" /* yacc.c:1646 */ 4826 4874 { (yyval.num) = THREADING_FREE; } 4827 - #line 4828 "parser.tab.c" /* yacc.c:1646 */ 4875 + #line 4876 "parser.tab.c" /* yacc.c:1646 */ 4828 4876 break; 4829 4877 4830 - case 374: 4831 - #line 1106 "parser.y" /* yacc.c:1646 */ 4878 + case 377: 4879 + #line 1131 "parser.y" /* yacc.c:1646 */ 4832 4880 { (yyval.num) = THREADING_BOTH; } 4833 - #line 4834 "parser.tab.c" /* yacc.c:1646 */ 4881 + #line 4882 "parser.tab.c" /* yacc.c:1646 */ 4834 4882 break; 4835 4883 4836 - case 375: 4837 - #line 1110 "parser.y" /* yacc.c:1646 */ 4838 - { (yyval.num) = RPC_FC_RP; } 4839 - #line 4840 "parser.tab.c" /* yacc.c:1646 */ 4884 + case 378: 4885 + #line 1135 "parser.y" /* yacc.c:1646 */ 4886 + { (yyval.num) = FC_RP; } 4887 + #line 4888 "parser.tab.c" /* yacc.c:1646 */ 4840 4888 break; 4841 4889 4842 - case 376: 4843 - #line 1111 "parser.y" /* yacc.c:1646 */ 4844 - { (yyval.num) = RPC_FC_UP; } 4845 - #line 4846 "parser.tab.c" /* yacc.c:1646 */ 4890 + case 379: 4891 + #line 1136 "parser.y" /* yacc.c:1646 */ 4892 + { (yyval.num) = FC_UP; } 4893 + #line 4894 "parser.tab.c" /* yacc.c:1646 */ 4846 4894 break; 4847 4895 4848 - case 377: 4849 - #line 1112 "parser.y" /* yacc.c:1646 */ 4850 - { (yyval.num) = RPC_FC_FP; } 4851 - #line 4852 "parser.tab.c" /* yacc.c:1646 */ 4896 + case 380: 4897 + #line 1137 "parser.y" /* yacc.c:1646 */ 4898 + { (yyval.num) = FC_FP; } 4899 + #line 4900 "parser.tab.c" /* yacc.c:1646 */ 4852 4900 break; 4853 4901 4854 - case 378: 4855 - #line 1115 "parser.y" /* yacc.c:1646 */ 4902 + case 381: 4903 + #line 1140 "parser.y" /* yacc.c:1646 */ 4856 4904 { (yyval.type) = type_new_struct((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); } 4857 - #line 4858 "parser.tab.c" /* yacc.c:1646 */ 4905 + #line 4906 "parser.tab.c" /* yacc.c:1646 */ 4858 4906 break; 4859 4907 4860 - case 379: 4861 - #line 1118 "parser.y" /* yacc.c:1646 */ 4908 + case 382: 4909 + #line 1143 "parser.y" /* yacc.c:1646 */ 4862 4910 { (yyval.type) = type_new_void(); } 4863 - #line 4864 "parser.tab.c" /* yacc.c:1646 */ 4911 + #line 4912 "parser.tab.c" /* yacc.c:1646 */ 4864 4912 break; 4865 4913 4866 - case 380: 4867 - #line 1119 "parser.y" /* yacc.c:1646 */ 4914 + case 383: 4915 + #line 1144 "parser.y" /* yacc.c:1646 */ 4868 4916 { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); } 4869 - #line 4870 "parser.tab.c" /* yacc.c:1646 */ 4917 + #line 4918 "parser.tab.c" /* yacc.c:1646 */ 4870 4918 break; 4871 4919 4872 - case 381: 4873 - #line 1120 "parser.y" /* yacc.c:1646 */ 4920 + case 384: 4921 + #line 1145 "parser.y" /* yacc.c:1646 */ 4874 4922 { (yyval.type) = (yyvsp[0].type); } 4875 - #line 4876 "parser.tab.c" /* yacc.c:1646 */ 4923 + #line 4924 "parser.tab.c" /* yacc.c:1646 */ 4876 4924 break; 4877 4925 4878 - case 382: 4879 - #line 1121 "parser.y" /* yacc.c:1646 */ 4926 + case 385: 4927 + #line 1146 "parser.y" /* yacc.c:1646 */ 4880 4928 { (yyval.type) = (yyvsp[0].type); } 4881 - #line 4882 "parser.tab.c" /* yacc.c:1646 */ 4929 + #line 4930 "parser.tab.c" /* yacc.c:1646 */ 4882 4930 break; 4883 4931 4884 - case 383: 4885 - #line 1122 "parser.y" /* yacc.c:1646 */ 4932 + case 386: 4933 + #line 1147 "parser.y" /* yacc.c:1646 */ 4886 4934 { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); } 4887 - #line 4888 "parser.tab.c" /* yacc.c:1646 */ 4935 + #line 4936 "parser.tab.c" /* yacc.c:1646 */ 4888 4936 break; 4889 4937 4890 - case 384: 4891 - #line 1123 "parser.y" /* yacc.c:1646 */ 4938 + case 387: 4939 + #line 1148 "parser.y" /* yacc.c:1646 */ 4892 4940 { (yyval.type) = (yyvsp[0].type); } 4893 - #line 4894 "parser.tab.c" /* yacc.c:1646 */ 4941 + #line 4942 "parser.tab.c" /* yacc.c:1646 */ 4894 4942 break; 4895 4943 4896 - case 385: 4897 - #line 1124 "parser.y" /* yacc.c:1646 */ 4944 + case 388: 4945 + #line 1149 "parser.y" /* yacc.c:1646 */ 4898 4946 { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); } 4899 - #line 4900 "parser.tab.c" /* yacc.c:1646 */ 4947 + #line 4948 "parser.tab.c" /* yacc.c:1646 */ 4900 4948 break; 4901 4949 4902 - case 386: 4903 - #line 1125 "parser.y" /* yacc.c:1646 */ 4950 + case 389: 4951 + #line 1150 "parser.y" /* yacc.c:1646 */ 4904 4952 { (yyval.type) = (yyvsp[0].type); } 4905 - #line 4906 "parser.tab.c" /* yacc.c:1646 */ 4953 + #line 4954 "parser.tab.c" /* yacc.c:1646 */ 4906 4954 break; 4907 4955 4908 - case 387: 4909 - #line 1126 "parser.y" /* yacc.c:1646 */ 4956 + case 390: 4957 + #line 1151 "parser.y" /* yacc.c:1646 */ 4910 4958 { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); } 4911 - #line 4912 "parser.tab.c" /* yacc.c:1646 */ 4959 + #line 4960 "parser.tab.c" /* yacc.c:1646 */ 4912 4960 break; 4913 4961 4914 - case 388: 4915 - #line 1127 "parser.y" /* yacc.c:1646 */ 4962 + case 391: 4963 + #line 1152 "parser.y" /* yacc.c:1646 */ 4916 4964 { (yyval.type) = make_safearray((yyvsp[-1].type)); } 4917 - #line 4918 "parser.tab.c" /* yacc.c:1646 */ 4965 + #line 4966 "parser.tab.c" /* yacc.c:1646 */ 4918 4966 break; 4919 4967 4920 - case 389: 4921 - #line 1131 "parser.y" /* yacc.c:1646 */ 4968 + case 392: 4969 + #line 1156 "parser.y" /* yacc.c:1646 */ 4922 4970 { (yyvsp[-4].attr_list) = append_attribs((yyvsp[-4].attr_list), (yyvsp[-2].attr_list)); 4923 4971 reg_typedefs((yyvsp[-1].declspec), (yyvsp[0].declarator_list), check_typedef_attrs((yyvsp[-4].attr_list))); 4924 4972 (yyval.statement) = make_statement_typedef((yyvsp[0].declarator_list)); 4925 4973 } 4926 - #line 4927 "parser.tab.c" /* yacc.c:1646 */ 4974 + #line 4975 "parser.tab.c" /* yacc.c:1646 */ 4927 4975 break; 4928 4976 4929 - case 390: 4930 - #line 1138 "parser.y" /* yacc.c:1646 */ 4977 + case 393: 4978 + #line 1163 "parser.y" /* yacc.c:1646 */ 4931 4979 { (yyval.type) = type_new_nonencapsulated_union((yyvsp[-3].str), TRUE, (yyvsp[-1].var_list)); } 4932 - #line 4933 "parser.tab.c" /* yacc.c:1646 */ 4980 + #line 4981 "parser.tab.c" /* yacc.c:1646 */ 4933 4981 break; 4934 4982 4935 - case 391: 4936 - #line 1141 "parser.y" /* yacc.c:1646 */ 4983 + case 394: 4984 + #line 1166 "parser.y" /* yacc.c:1646 */ 4937 4985 { (yyval.type) = type_new_encapsulated_union((yyvsp[-8].str), (yyvsp[-5].var), (yyvsp[-3].var), (yyvsp[-1].var_list)); } 4938 - #line 4939 "parser.tab.c" /* yacc.c:1646 */ 4986 + #line 4987 "parser.tab.c" /* yacc.c:1646 */ 4939 4987 break; 4940 4988 4941 - case 392: 4942 - #line 1145 "parser.y" /* yacc.c:1646 */ 4989 + case 395: 4990 + #line 1170 "parser.y" /* yacc.c:1646 */ 4943 4991 { (yyval.num) = MAKEVERSION((yyvsp[0].num), 0); } 4944 - #line 4945 "parser.tab.c" /* yacc.c:1646 */ 4992 + #line 4993 "parser.tab.c" /* yacc.c:1646 */ 4945 4993 break; 4946 4994 4947 - case 393: 4948 - #line 1146 "parser.y" /* yacc.c:1646 */ 4995 + case 396: 4996 + #line 1171 "parser.y" /* yacc.c:1646 */ 4949 4997 { (yyval.num) = MAKEVERSION((yyvsp[-2].num), (yyvsp[0].num)); } 4950 - #line 4951 "parser.tab.c" /* yacc.c:1646 */ 4998 + #line 4999 "parser.tab.c" /* yacc.c:1646 */ 4951 4999 break; 4952 5000 4953 - case 394: 4954 - #line 1147 "parser.y" /* yacc.c:1646 */ 5001 + case 397: 5002 + #line 1172 "parser.y" /* yacc.c:1646 */ 4955 5003 { (yyval.num) = (yyvsp[0].num); } 4956 - #line 4957 "parser.tab.c" /* yacc.c:1646 */ 5004 + #line 5005 "parser.tab.c" /* yacc.c:1646 */ 5005 + break; 5006 + 5007 + case 402: 5008 + #line 1185 "parser.y" /* yacc.c:1646 */ 5009 + { type_t *type = find_type_or_error((yyvsp[-1].str), 0); 5010 + type->attrs = append_attr_list(type->attrs, (yyvsp[-2].attr_list)); 5011 + } 5012 + #line 5013 "parser.tab.c" /* yacc.c:1646 */ 5013 + break; 5014 + 5015 + case 403: 5016 + #line 1190 "parser.y" /* yacc.c:1646 */ 5017 + { type_t *iface = find_type_or_error2((yyvsp[-3].str), 0); 5018 + if (type_get_type(iface) != TYPE_INTERFACE) 5019 + error_loc("%s is not an interface\n", iface->name); 5020 + iface->attrs = append_attr_list(iface->attrs, (yyvsp[-5].attr_list)); 5021 + } 5022 + #line 5023 "parser.tab.c" /* yacc.c:1646 */ 5023 + break; 5024 + 5025 + case 404: 5026 + #line 1197 "parser.y" /* yacc.c:1646 */ 5027 + { (yyval.attr_list) = NULL; } 5028 + #line 5029 "parser.tab.c" /* yacc.c:1646 */ 5029 + break; 5030 + 5031 + case 405: 5032 + #line 1198 "parser.y" /* yacc.c:1646 */ 5033 + { (yyval.attr_list) = (yyvsp[-1].attr_list); } 5034 + #line 5035 "parser.tab.c" /* yacc.c:1646 */ 5035 + break; 5036 + 5037 + case 406: 5038 + #line 1201 "parser.y" /* yacc.c:1646 */ 5039 + { (yyval.attr_list) = append_attr(NULL, (yyvsp[0].attr)); } 5040 + #line 5041 "parser.tab.c" /* yacc.c:1646 */ 5041 + break; 5042 + 5043 + case 407: 5044 + #line 1202 "parser.y" /* yacc.c:1646 */ 5045 + { (yyval.attr_list) = append_attr((yyvsp[-2].attr_list), (yyvsp[0].attr)); } 5046 + #line 5047 "parser.tab.c" /* yacc.c:1646 */ 5047 + break; 5048 + 5049 + case 408: 5050 + #line 1205 "parser.y" /* yacc.c:1646 */ 5051 + { (yyval.attr) = make_attr(ATTR_ENCODE); } 5052 + #line 5053 "parser.tab.c" /* yacc.c:1646 */ 5053 + break; 5054 + 5055 + case 409: 5056 + #line 1206 "parser.y" /* yacc.c:1646 */ 5057 + { (yyval.attr) = make_attr(ATTR_DECODE); } 5058 + #line 5059 "parser.tab.c" /* yacc.c:1646 */ 5059 + break; 5060 + 5061 + case 410: 5062 + #line 1207 "parser.y" /* yacc.c:1646 */ 5063 + { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); } 5064 + #line 5065 "parser.tab.c" /* yacc.c:1646 */ 4957 5065 break; 4958 5066 4959 5067 4960 - #line 4961 "parser.tab.c" /* yacc.c:1646 */ 5068 + #line 5069 "parser.tab.c" /* yacc.c:1646 */ 4961 5069 default: break; 4962 5070 } 4963 5071 /* User semantic actions sometimes alter yychar, and that requires ··· 5185 5293 #endif 5186 5294 return yyresult; 5187 5295 } 5188 - #line 1150 "parser.y" /* yacc.c:1906 */ 5296 + #line 1209 "parser.y" /* yacc.c:1906 */ 5189 5297 5190 5298 5191 5299 static void decl_builtin_basic(const char *name, enum type_basic_type type) ··· 5275 5383 return new_list; 5276 5384 } 5277 5385 5278 - static attr_list_t *dupattrs(const attr_list_t *list) 5386 + typedef int (*map_attrs_filter_t)(attr_list_t*,const attr_t*); 5387 + 5388 + static attr_list_t *map_attrs(const attr_list_t *list, map_attrs_filter_t filter) 5279 5389 { 5280 5390 attr_list_t *new_list; 5281 5391 const attr_t *attr; 5392 + attr_t *new_attr; 5282 5393 5283 5394 if (!list) return NULL; 5284 5395 ··· 5286 5397 list_init( new_list ); 5287 5398 LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry) 5288 5399 { 5289 - attr_t *new_attr = xmalloc(sizeof(*new_attr)); 5400 + if (filter && !filter(new_list, attr)) continue; 5401 + new_attr = xmalloc(sizeof(*new_attr)); 5290 5402 *new_attr = *attr; 5291 5403 list_add_tail(new_list, &new_attr->entry); 5292 5404 } ··· 5336 5448 { 5337 5449 attr_list_t *attrs; 5338 5450 declspec->type = duptype(type, 1); 5339 - attrs = dupattrs(type->attrs); 5451 + attrs = map_attrs(type->attrs, NULL); 5340 5452 declspec->type->attrs = append_attr_list(attrs, declspec->attrs); 5341 5453 declspec->attrs = NULL; 5342 5454 } ··· 5380 5492 return list; 5381 5493 } 5382 5494 5383 - static array_dims_t *append_array(array_dims_t *list, expr_t *expr) 5495 + static type_t *append_array(type_t *chain, expr_t *expr) 5384 5496 { 5385 - if (!expr) return list; 5386 - if (!list) 5387 - { 5388 - list = xmalloc( sizeof(*list) ); 5389 - list_init( list ); 5390 - } 5391 - list_add_tail( list, &expr->entry ); 5392 - return list; 5497 + type_t *array; 5498 + 5499 + if (!expr) 5500 + return chain; 5501 + 5502 + /* An array is always a reference pointer unless explicitly marked otherwise 5503 + * (regardless of what the default pointer attribute is). */ 5504 + array = type_new_array(NULL, NULL, FALSE, expr->is_const ? expr->cval : 0, 5505 + expr->is_const ? NULL : expr, NULL, FC_RP); 5506 + 5507 + return append_chain_type(chain, array); 5393 5508 } 5394 5509 5395 5510 static struct list type_pool = LIST_INIT(type_pool); ··· 5445 5560 case TYPE_BASIC_INT64: 5446 5561 case TYPE_BASIC_INT: 5447 5562 case TYPE_BASIC_INT3264: 5563 + case TYPE_BASIC_LONG: 5448 5564 case TYPE_BASIC_BYTE: 5449 5565 case TYPE_BASIC_CHAR: 5450 5566 case TYPE_BASIC_WCHAR: ··· 5462 5578 } 5463 5579 } 5464 5580 5465 - static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type) 5581 + static type_t *get_array_or_ptr_ref(type_t *type) 5466 5582 { 5467 - type_t *ptrchain_type; 5468 - if (!ptrchain) 5469 - return type; 5470 - for (ptrchain_type = ptrchain; type_pointer_get_ref(ptrchain_type); ptrchain_type = type_pointer_get_ref(ptrchain_type)) 5471 - ; 5472 - assert(ptrchain_type->type_type == TYPE_POINTER); 5473 - ptrchain_type->details.pointer.ref = type; 5474 - return ptrchain; 5583 + if (is_ptr(type)) 5584 + return type_pointer_get_ref(type); 5585 + else if (is_array(type)) 5586 + return type_array_get_element(type); 5587 + return NULL; 5588 + } 5589 + 5590 + static type_t *append_chain_type(type_t *chain, type_t *type) 5591 + { 5592 + type_t *chain_type; 5593 + 5594 + if (!chain) 5595 + return type; 5596 + for (chain_type = chain; get_array_or_ptr_ref(chain_type); chain_type = get_array_or_ptr_ref(chain_type)) 5597 + ; 5598 + 5599 + if (is_ptr(chain_type)) 5600 + chain_type->details.pointer.ref = type; 5601 + else if (is_array(chain_type)) 5602 + chain_type->details.array.elem = type; 5603 + else 5604 + assert(0); 5605 + 5606 + return chain; 5475 5607 } 5476 5608 5477 5609 static warning_list_t *append_warning(warning_list_t *list, int num) ··· 5495 5627 var_t *v = decl->var; 5496 5628 expr_list_t *sizes = get_attrp(attrs, ATTR_SIZEIS); 5497 5629 expr_list_t *lengs = get_attrp(attrs, ATTR_LENGTHIS); 5498 - int sizeless; 5499 5630 expr_t *dim; 5500 5631 type_t **ptype; 5501 - array_dims_t *arr = decl ? decl->array : NULL; 5502 5632 type_t *func_type = decl ? decl->func_type : NULL; 5503 5633 type_t *type = decl_spec->type; 5504 5634 ··· 5517 5647 } 5518 5648 5519 5649 /* add type onto the end of the pointers in pident->type */ 5520 - v->type = append_ptrchain_type(decl ? decl->type : NULL, type); 5650 + v->type = append_chain_type(decl ? decl->type : NULL, type); 5521 5651 v->stgclass = decl_spec->stgclass; 5522 5652 v->attrs = attrs; 5523 5653 5524 5654 /* check for pointer attribute being applied to non-pointer, non-array 5525 5655 * type */ 5526 - if (!arr) 5656 + if (!is_array(v->type)) 5527 5657 { 5528 5658 int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE); 5529 5659 const type_t *ptr = NULL; ··· 5540 5670 } 5541 5671 if (is_ptr(ptr)) 5542 5672 { 5543 - if (ptr_attr && ptr_attr != RPC_FC_UP && 5673 + if (ptr_attr && ptr_attr != FC_UP && 5544 5674 type_get_type(type_pointer_get_ref(ptr)) == TYPE_INTERFACE) 5545 5675 warning_loc_info(&v->loc_info, 5546 5676 "%s: pointer attribute applied to interface " 5547 5677 "pointer type has no effect\n", v->name); 5548 - if (!ptr_attr && top && (*pt)->details.pointer.def_fc != RPC_FC_RP) 5678 + if (!ptr_attr && top && (*pt)->details.pointer.def_fc != FC_RP) 5549 5679 { 5550 5680 /* FIXME: this is a horrible hack to cope with the issue that we 5551 5681 * store an offset to the typeformat string in the type object, but ··· 5562 5692 { 5563 5693 type_t *t = type; 5564 5694 5565 - if (!is_ptr(v->type) && !arr) 5695 + if (!is_ptr(v->type) && !is_array(v->type)) 5566 5696 error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n", 5567 5697 v->name); 5568 5698 5569 - while (is_ptr(t)) 5570 - t = type_pointer_get_ref(t); 5699 + for (;;) 5700 + { 5701 + if (is_ptr(t)) 5702 + t = type_pointer_get_ref(t); 5703 + else if (is_array(t)) 5704 + t = type_array_get_element(t); 5705 + else 5706 + break; 5707 + } 5571 5708 5572 5709 if (type_get_type(t) != TYPE_BASIC && 5573 - (get_basic_fc(t) != RPC_FC_CHAR && 5574 - get_basic_fc(t) != RPC_FC_BYTE && 5575 - get_basic_fc(t) != RPC_FC_WCHAR)) 5710 + (get_basic_fc(t) != FC_CHAR && 5711 + get_basic_fc(t) != FC_BYTE && 5712 + get_basic_fc(t) != FC_WCHAR)) 5576 5713 { 5577 5714 error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n", 5578 5715 v->name); ··· 5588 5725 if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->type)) 5589 5726 error_loc("'%s': [range] attribute applied to non-integer type\n", 5590 5727 v->name); 5591 - 5592 - ptype = &v->type; 5593 - sizeless = FALSE; 5594 - if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry) 5595 - { 5596 - if (sizeless) 5597 - error_loc("%s: only the first array dimension can be unspecified\n", v->name); 5598 - 5599 - if (dim->is_const) 5600 - { 5601 - if (dim->cval <= 0) 5602 - error_loc("%s: array dimension must be positive\n", v->name); 5603 - 5604 - /* FIXME: should use a type_memsize that allows us to pass in a pointer size */ 5605 - if (0) 5606 - { 5607 - unsigned int size = type_memsize(v->type); 5608 - 5609 - if (0xffffffffu / size < dim->cval) 5610 - error_loc("%s: total array size is too large\n", v->name); 5611 - } 5612 - } 5613 - else 5614 - sizeless = TRUE; 5615 - 5616 - *ptype = type_new_array(NULL, *ptype, FALSE, 5617 - dim->is_const ? dim->cval : 0, 5618 - dim->is_const ? NULL : dim, NULL, 5619 - pointer_default); 5620 - } 5621 5728 5622 5729 ptype = &v->type; 5623 5730 if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry) ··· 5778 5885 return v; 5779 5886 } 5780 5887 5888 + static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter) 5889 + { 5890 + var_t *v = xmalloc(sizeof(var_t)); 5891 + v->name = name; 5892 + v->type = src->type; 5893 + v->attrs = map_attrs(src->attrs, attr_filter); 5894 + v->eval = src->eval; 5895 + v->stgclass = src->stgclass; 5896 + v->loc_info = src->loc_info; 5897 + return v; 5898 + } 5899 + 5781 5900 static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d) 5782 5901 { 5783 5902 if (!d) return list; ··· 5795 5914 d->var = var ? var : make_var(NULL); 5796 5915 d->type = NULL; 5797 5916 d->func_type = NULL; 5798 - d->array = NULL; 5799 5917 d->bits = NULL; 5800 5918 return d; 5801 5919 } ··· 5803 5921 static type_t *make_safearray(type_t *type) 5804 5922 { 5805 5923 return type_new_array(NULL, type_new_alias(type, "SAFEARRAY"), TRUE, 0, 5806 - NULL, NULL, RPC_FC_RP); 5924 + NULL, NULL, FC_RP); 5807 5925 } 5808 5926 5809 5927 static typelib_t *make_library(const char *name, const attr_list_t *attrs) ··· 6454 6572 case TYPE_BASIC_INT32: 6455 6573 case TYPE_BASIC_INT64: 6456 6574 case TYPE_BASIC_INT: 6575 + case TYPE_BASIC_LONG: 6457 6576 case TYPE_BASIC_CHAR: 6458 6577 case TYPE_BASIC_HYPER: 6459 6578 case TYPE_BASIC_BYTE: ··· 6792 6911 check_remoting_args(func); 6793 6912 } 6794 6913 } 6914 + } 6915 + 6916 + static char *concat_str(const char *prefix, const char *str) 6917 + { 6918 + char *ret = xmalloc(strlen(prefix) + strlen(str) + 1); 6919 + strcpy(ret, prefix); 6920 + strcat(ret, str); 6921 + return ret; 6922 + } 6923 + 6924 + static int async_iface_attrs(attr_list_t *attrs, const attr_t *attr) 6925 + { 6926 + switch(attr->type) 6927 + { 6928 + case ATTR_UUID: 6929 + return 0; 6930 + case ATTR_ASYNCUUID: 6931 + append_attr(attrs, make_attrp(ATTR_UUID, attr->u.pval)); 6932 + return 0; 6933 + default: 6934 + return 1; 6935 + } 6936 + } 6937 + 6938 + static int arg_in_attrs(attr_list_t *attrs, const attr_t *attr) 6939 + { 6940 + return attr->type != ATTR_OUT && attr->type != ATTR_RETVAL; 6941 + } 6942 + 6943 + static int arg_out_attrs(attr_list_t *attrs, const attr_t *attr) 6944 + { 6945 + return attr->type != ATTR_IN; 6946 + } 6947 + 6948 + static void check_async_uuid(type_t *iface) 6949 + { 6950 + statement_list_t *stmts = NULL; 6951 + statement_t *stmt; 6952 + type_t *async_iface; 6953 + type_t *inherit; 6954 + 6955 + if (!is_attr(iface->attrs, ATTR_ASYNCUUID)) return; 6956 + 6957 + inherit = iface->details.iface->inherit; 6958 + if (inherit && strcmp(inherit->name, "IUnknown")) 6959 + inherit = inherit->details.iface->async_iface; 6960 + if (!inherit) 6961 + error_loc("async_uuid applied to an interface with incompatible parent\n"); 6962 + 6963 + async_iface = get_type(TYPE_INTERFACE, concat_str("Async", iface->name), iface->namespace, 0); 6964 + async_iface->attrs = map_attrs(iface->attrs, async_iface_attrs); 6965 + 6966 + STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) 6967 + { 6968 + var_t *begin_func, *finish_func, *func = stmt->u.var, *arg; 6969 + var_list_t *begin_args = NULL, *finish_args = NULL, *args; 6970 + 6971 + args = func->type->details.function->args; 6972 + if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry) 6973 + { 6974 + if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT)) 6975 + begin_args = append_var(begin_args, copy_var(arg, strdup(arg->name), arg_in_attrs)); 6976 + if (is_attr(arg->attrs, ATTR_OUT)) 6977 + finish_args = append_var(finish_args, copy_var(arg, strdup(arg->name), arg_out_attrs)); 6978 + } 6979 + 6980 + begin_func = copy_var(func, concat_str("Begin_", func->name), NULL); 6981 + begin_func->type = type_new_function(begin_args); 6982 + begin_func->type->attrs = func->attrs; 6983 + begin_func->type->details.function->retval = func->type->details.function->retval; 6984 + stmts = append_statement(stmts, make_statement_declaration(begin_func)); 6985 + 6986 + finish_func = copy_var(func, concat_str("Finish_", func->name), NULL); 6987 + finish_func->type = type_new_function(finish_args); 6988 + finish_func->type->attrs = func->attrs; 6989 + finish_func->type->details.function->retval = func->type->details.function->retval; 6990 + stmts = append_statement(stmts, make_statement_declaration(finish_func)); 6991 + } 6992 + 6993 + type_interface_define(async_iface, inherit, stmts); 6994 + iface->details.iface->async_iface = async_iface->details.iface->async_iface = async_iface; 6795 6995 } 6796 6996 6797 6997 static void check_statements(const statement_list_t *stmts, int is_inside_library)
+180 -179
sdk/tools/widl/parser.tab.h
··· 30 30 This special exception was added by the Free Software Foundation in 31 31 version 2.2 of Bison. */ 32 32 33 - #ifndef YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 34 - # define YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 33 + #ifndef YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 34 + # define YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED 35 35 /* Debug traces. */ 36 36 #ifndef YYDEBUG 37 37 # define YYDEBUG 0 ··· 56 56 aSQSTRING = 266, 57 57 aUUID = 267, 58 58 aEOF = 268, 59 - SHL = 269, 60 - SHR = 270, 61 - MEMBERPTR = 271, 62 - EQUALITY = 272, 63 - INEQUALITY = 273, 64 - GREATEREQUAL = 274, 65 - LESSEQUAL = 275, 66 - LOGICALOR = 276, 67 - LOGICALAND = 277, 68 - ELLIPSIS = 278, 69 - tAGGREGATABLE = 279, 70 - tALLOCATE = 280, 71 - tANNOTATION = 281, 72 - tAPPOBJECT = 282, 73 - tASYNC = 283, 74 - tASYNCUUID = 284, 75 - tAUTOHANDLE = 285, 76 - tBINDABLE = 286, 77 - tBOOLEAN = 287, 78 - tBROADCAST = 288, 79 - tBYTE = 289, 80 - tBYTECOUNT = 290, 81 - tCALLAS = 291, 82 - tCALLBACK = 292, 83 - tCASE = 293, 84 - tCDECL = 294, 85 - tCHAR = 295, 86 - tCOCLASS = 296, 87 - tCODE = 297, 88 - tCOMMSTATUS = 298, 89 - tCONST = 299, 90 - tCONTEXTHANDLE = 300, 91 - tCONTEXTHANDLENOSERIALIZE = 301, 92 - tCONTEXTHANDLESERIALIZE = 302, 93 - tCONTROL = 303, 94 - tCPPQUOTE = 304, 95 - tDECODE = 305, 96 - tDEFAULT = 306, 97 - tDEFAULTBIND = 307, 98 - tDEFAULTCOLLELEM = 308, 99 - tDEFAULTVALUE = 309, 100 - tDEFAULTVTABLE = 310, 101 - tDISABLECONSISTENCYCHECK = 311, 102 - tDISPLAYBIND = 312, 103 - tDISPINTERFACE = 313, 104 - tDLLNAME = 314, 105 - tDOUBLE = 315, 106 - tDUAL = 316, 107 - tENABLEALLOCATE = 317, 108 - tENCODE = 318, 109 - tENDPOINT = 319, 110 - tENTRY = 320, 111 - tENUM = 321, 112 - tERRORSTATUST = 322, 113 - tEXPLICITHANDLE = 323, 114 - tEXTERN = 324, 115 - tFALSE = 325, 116 - tFASTCALL = 326, 117 - tFAULTSTATUS = 327, 118 - tFLOAT = 328, 119 - tFORCEALLOCATE = 329, 120 - tHANDLE = 330, 121 - tHANDLET = 331, 122 - tHELPCONTEXT = 332, 123 - tHELPFILE = 333, 124 - tHELPSTRING = 334, 125 - tHELPSTRINGCONTEXT = 335, 126 - tHELPSTRINGDLL = 336, 127 - tHIDDEN = 337, 128 - tHYPER = 338, 129 - tID = 339, 130 - tIDEMPOTENT = 340, 131 - tIGNORE = 341, 132 - tIIDIS = 342, 133 - tIMMEDIATEBIND = 343, 134 - tIMPLICITHANDLE = 344, 135 - tIMPORT = 345, 136 - tIMPORTLIB = 346, 137 - tIN = 347, 138 - tIN_LINE = 348, 139 - tINLINE = 349, 140 - tINPUTSYNC = 350, 141 - tINT = 351, 142 - tINT3264 = 352, 143 - tINT64 = 353, 144 - tINTERFACE = 354, 145 - tLCID = 355, 146 - tLENGTHIS = 356, 147 - tLIBRARY = 357, 148 - tLICENSED = 358, 149 - tLOCAL = 359, 150 - tLONG = 360, 151 - tMAYBE = 361, 152 - tMESSAGE = 362, 153 - tMETHODS = 363, 154 - tMODULE = 364, 155 - tNAMESPACE = 365, 156 - tNOCODE = 366, 157 - tNONBROWSABLE = 367, 158 - tNONCREATABLE = 368, 159 - tNONEXTENSIBLE = 369, 160 - tNOTIFY = 370, 161 - tNOTIFYFLAG = 371, 162 - tNULL = 372, 163 - tOBJECT = 373, 164 - tODL = 374, 165 - tOLEAUTOMATION = 375, 166 - tOPTIMIZE = 376, 167 - tOPTIONAL = 377, 168 - tOUT = 378, 169 - tPARTIALIGNORE = 379, 170 - tPASCAL = 380, 171 - tPOINTERDEFAULT = 381, 172 - tPRAGMA_WARNING = 382, 173 - tPROGID = 383, 174 - tPROPERTIES = 384, 175 - tPROPGET = 385, 176 - tPROPPUT = 386, 177 - tPROPPUTREF = 387, 178 - tPROXY = 388, 179 - tPTR = 389, 180 - tPUBLIC = 390, 181 - tRANGE = 391, 182 - tREADONLY = 392, 183 - tREF = 393, 184 - tREGISTER = 394, 185 - tREPRESENTAS = 395, 186 - tREQUESTEDIT = 396, 187 - tRESTRICTED = 397, 188 - tRETVAL = 398, 189 - tSAFEARRAY = 399, 190 - tSHORT = 400, 191 - tSIGNED = 401, 192 - tSIZEIS = 402, 193 - tSIZEOF = 403, 194 - tSMALL = 404, 195 - tSOURCE = 405, 196 - tSTATIC = 406, 197 - tSTDCALL = 407, 198 - tSTRICTCONTEXTHANDLE = 408, 199 - tSTRING = 409, 200 - tSTRUCT = 410, 201 - tSWITCH = 411, 202 - tSWITCHIS = 412, 203 - tSWITCHTYPE = 413, 204 - tTHREADING = 414, 205 - tTRANSMITAS = 415, 206 - tTRUE = 416, 207 - tTYPEDEF = 417, 208 - tUIDEFAULT = 418, 209 - tUNION = 419, 210 - tUNIQUE = 420, 211 - tUNSIGNED = 421, 212 - tUSESGETLASTERROR = 422, 213 - tUSERMARSHAL = 423, 214 - tUUID = 424, 215 - tV1ENUM = 425, 216 - tVARARG = 426, 217 - tVERSION = 427, 218 - tVIPROGID = 428, 219 - tVOID = 429, 220 - tWCHAR = 430, 221 - tWIREMARSHAL = 431, 222 - tAPARTMENT = 432, 223 - tNEUTRAL = 433, 224 - tSINGLE = 434, 225 - tFREE = 435, 226 - tBOTH = 436, 227 - CAST = 437, 228 - PPTR = 438, 229 - POS = 439, 230 - NEG = 440, 231 - ADDRESSOF = 441 59 + aACF = 269, 60 + SHL = 270, 61 + SHR = 271, 62 + MEMBERPTR = 272, 63 + EQUALITY = 273, 64 + INEQUALITY = 274, 65 + GREATEREQUAL = 275, 66 + LESSEQUAL = 276, 67 + LOGICALOR = 277, 68 + LOGICALAND = 278, 69 + ELLIPSIS = 279, 70 + tAGGREGATABLE = 280, 71 + tALLOCATE = 281, 72 + tANNOTATION = 282, 73 + tAPPOBJECT = 283, 74 + tASYNC = 284, 75 + tASYNCUUID = 285, 76 + tAUTOHANDLE = 286, 77 + tBINDABLE = 287, 78 + tBOOLEAN = 288, 79 + tBROADCAST = 289, 80 + tBYTE = 290, 81 + tBYTECOUNT = 291, 82 + tCALLAS = 292, 83 + tCALLBACK = 293, 84 + tCASE = 294, 85 + tCDECL = 295, 86 + tCHAR = 296, 87 + tCOCLASS = 297, 88 + tCODE = 298, 89 + tCOMMSTATUS = 299, 90 + tCONST = 300, 91 + tCONTEXTHANDLE = 301, 92 + tCONTEXTHANDLENOSERIALIZE = 302, 93 + tCONTEXTHANDLESERIALIZE = 303, 94 + tCONTROL = 304, 95 + tCPPQUOTE = 305, 96 + tDECODE = 306, 97 + tDEFAULT = 307, 98 + tDEFAULTBIND = 308, 99 + tDEFAULTCOLLELEM = 309, 100 + tDEFAULTVALUE = 310, 101 + tDEFAULTVTABLE = 311, 102 + tDISABLECONSISTENCYCHECK = 312, 103 + tDISPLAYBIND = 313, 104 + tDISPINTERFACE = 314, 105 + tDLLNAME = 315, 106 + tDOUBLE = 316, 107 + tDUAL = 317, 108 + tENABLEALLOCATE = 318, 109 + tENCODE = 319, 110 + tENDPOINT = 320, 111 + tENTRY = 321, 112 + tENUM = 322, 113 + tERRORSTATUST = 323, 114 + tEXPLICITHANDLE = 324, 115 + tEXTERN = 325, 116 + tFALSE = 326, 117 + tFASTCALL = 327, 118 + tFAULTSTATUS = 328, 119 + tFLOAT = 329, 120 + tFORCEALLOCATE = 330, 121 + tHANDLE = 331, 122 + tHANDLET = 332, 123 + tHELPCONTEXT = 333, 124 + tHELPFILE = 334, 125 + tHELPSTRING = 335, 126 + tHELPSTRINGCONTEXT = 336, 127 + tHELPSTRINGDLL = 337, 128 + tHIDDEN = 338, 129 + tHYPER = 339, 130 + tID = 340, 131 + tIDEMPOTENT = 341, 132 + tIGNORE = 342, 133 + tIIDIS = 343, 134 + tIMMEDIATEBIND = 344, 135 + tIMPLICITHANDLE = 345, 136 + tIMPORT = 346, 137 + tIMPORTLIB = 347, 138 + tIN = 348, 139 + tIN_LINE = 349, 140 + tINLINE = 350, 141 + tINPUTSYNC = 351, 142 + tINT = 352, 143 + tINT32 = 353, 144 + tINT3264 = 354, 145 + tINT64 = 355, 146 + tINTERFACE = 356, 147 + tLCID = 357, 148 + tLENGTHIS = 358, 149 + tLIBRARY = 359, 150 + tLICENSED = 360, 151 + tLOCAL = 361, 152 + tLONG = 362, 153 + tMAYBE = 363, 154 + tMESSAGE = 364, 155 + tMETHODS = 365, 156 + tMODULE = 366, 157 + tNAMESPACE = 367, 158 + tNOCODE = 368, 159 + tNONBROWSABLE = 369, 160 + tNONCREATABLE = 370, 161 + tNONEXTENSIBLE = 371, 162 + tNOTIFY = 372, 163 + tNOTIFYFLAG = 373, 164 + tNULL = 374, 165 + tOBJECT = 375, 166 + tODL = 376, 167 + tOLEAUTOMATION = 377, 168 + tOPTIMIZE = 378, 169 + tOPTIONAL = 379, 170 + tOUT = 380, 171 + tPARTIALIGNORE = 381, 172 + tPASCAL = 382, 173 + tPOINTERDEFAULT = 383, 174 + tPRAGMA_WARNING = 384, 175 + tPROGID = 385, 176 + tPROPERTIES = 386, 177 + tPROPGET = 387, 178 + tPROPPUT = 388, 179 + tPROPPUTREF = 389, 180 + tPROXY = 390, 181 + tPTR = 391, 182 + tPUBLIC = 392, 183 + tRANGE = 393, 184 + tREADONLY = 394, 185 + tREF = 395, 186 + tREGISTER = 396, 187 + tREPRESENTAS = 397, 188 + tREQUESTEDIT = 398, 189 + tRESTRICTED = 399, 190 + tRETVAL = 400, 191 + tSAFEARRAY = 401, 192 + tSHORT = 402, 193 + tSIGNED = 403, 194 + tSIZEIS = 404, 195 + tSIZEOF = 405, 196 + tSMALL = 406, 197 + tSOURCE = 407, 198 + tSTATIC = 408, 199 + tSTDCALL = 409, 200 + tSTRICTCONTEXTHANDLE = 410, 201 + tSTRING = 411, 202 + tSTRUCT = 412, 203 + tSWITCH = 413, 204 + tSWITCHIS = 414, 205 + tSWITCHTYPE = 415, 206 + tTHREADING = 416, 207 + tTRANSMITAS = 417, 208 + tTRUE = 418, 209 + tTYPEDEF = 419, 210 + tUIDEFAULT = 420, 211 + tUNION = 421, 212 + tUNIQUE = 422, 213 + tUNSIGNED = 423, 214 + tUSESGETLASTERROR = 424, 215 + tUSERMARSHAL = 425, 216 + tUUID = 426, 217 + tV1ENUM = 427, 218 + tVARARG = 428, 219 + tVERSION = 429, 220 + tVIPROGID = 430, 221 + tVOID = 431, 222 + tWCHAR = 432, 223 + tWIREMARSHAL = 433, 224 + tAPARTMENT = 434, 225 + tNEUTRAL = 435, 226 + tSINGLE = 436, 227 + tFREE = 437, 228 + tBOTH = 438, 229 + CAST = 439, 230 + PPTR = 440, 231 + POS = 441, 232 + NEG = 442, 233 + ADDRESSOF = 443 232 234 }; 233 235 #endif 234 236 ··· 237 239 typedef union YYSTYPE YYSTYPE; 238 240 union YYSTYPE 239 241 { 240 - #line 138 "parser.y" /* yacc.c:1909 */ 242 + #line 144 "parser.y" /* yacc.c:1909 */ 241 243 242 244 attr_t *attr; 243 245 attr_list_t *attr_list; 244 246 str_list_t *str_list; 245 247 expr_t *expr; 246 248 expr_list_t *expr_list; 247 - array_dims_t *array_dims; 248 249 type_t *type; 249 250 var_t *var; 250 251 var_list_t *var_list; ··· 266 267 struct _decl_spec_t *declspec; 267 268 enum storage_class stgclass; 268 269 269 - #line 270 "parser.tab.h" /* yacc.c:1909 */ 270 + #line 271 "parser.tab.h" /* yacc.c:1909 */ 270 271 }; 271 272 # define YYSTYPE_IS_TRIVIAL 1 272 273 # define YYSTYPE_IS_DECLARED 1 ··· 277 278 278 279 int parser_parse (void); 279 280 280 - #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */ 281 + #endif /* !YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */
+245 -94
sdk/tools/widl/parser.y
··· 38 38 #include "expr.h" 39 39 #include "typetree.h" 40 40 41 - static unsigned char pointer_default = RPC_FC_UP; 41 + static unsigned char pointer_default = FC_UP; 42 42 43 43 typedef struct list typelist_t; 44 44 struct typenode { ··· 72 72 static attr_t *make_attrv(enum attr_type type, unsigned int val); 73 73 static attr_t *make_attrp(enum attr_type type, void *val); 74 74 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr); 75 - static array_dims_t *append_array(array_dims_t *list, expr_t *expr); 75 + static type_t *append_array(type_t *chain, expr_t *expr); 76 76 static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top); 77 77 static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls); 78 78 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface); ··· 82 82 static declarator_t *make_declarator(var_t *var); 83 83 static type_t *make_safearray(type_t *type); 84 84 static typelib_t *make_library(const char *name, const attr_list_t *attrs); 85 - static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type); 85 + static type_t *append_chain_type(type_t *chain, type_t *type); 86 86 static warning_list_t *append_warning(warning_list_t *, int); 87 87 88 88 static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs); ··· 113 113 static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func); 114 114 static void check_def(const type_t *t); 115 115 116 + static void check_async_uuid(type_t *iface); 117 + 116 118 static statement_t *make_statement(enum statement_type type); 117 119 static statement_t *make_statement_type_decl(type_t *type); 118 120 static statement_t *make_statement_reference(type_t *type); ··· 134 136 135 137 static struct namespace *current_namespace = &global_namespace; 136 138 139 + #ifndef __REACTOS__ 140 + static typelib_t *current_typelib; 141 + #endif 142 + 137 143 %} 138 144 %union { 139 145 attr_t *attr; ··· 141 147 str_list_t *str_list; 142 148 expr_t *expr; 143 149 expr_list_t *expr_list; 144 - array_dims_t *array_dims; 145 150 type_t *type; 146 151 var_t *var; 147 152 var_list_t *var_list; ··· 170 175 %token <dbl> aDOUBLE 171 176 %token <str> aSTRING aWSTRING aSQSTRING 172 177 %token <uuid> aUUID 173 - %token aEOF 178 + %token aEOF aACF 174 179 %token SHL SHR 175 180 %token MEMBERPTR 176 181 %token EQUALITY INEQUALITY ··· 207 212 %token tIMPORT tIMPORTLIB 208 213 %token tIN tIN_LINE tINLINE 209 214 %token tINPUTSYNC 210 - %token tINT tINT3264 tINT64 215 + %token tINT tINT32 tINT3264 tINT64 211 216 %token tINTERFACE 212 217 %token tLCID 213 218 %token tLENGTHIS tLIBRARY ··· 263 268 %token tWCHAR tWIREMARSHAL 264 269 %token tAPARTMENT tNEUTRAL tSINGLE tFREE tBOTH 265 270 266 - %type <attr> attribute type_qualifier function_specifier 271 + %type <attr> attribute type_qualifier function_specifier acf_attribute 267 272 %type <attr_list> m_attributes attributes attrib_list m_type_qual_list 273 + %type <attr_list> acf_attributes acf_attribute_list 268 274 %type <str_list> str_list 269 275 %type <expr> m_expr expr expr_const expr_int_const array m_bitfield 270 276 %type <expr_list> m_exprs /* exprs expr_list */ expr_list_int_const ··· 318 324 319 325 %% 320 326 321 - input: gbl_statements { fix_incomplete(); 327 + input: gbl_statements m_acf { fix_incomplete(); 322 328 check_statements($1, FALSE); 323 329 check_all_user_types($1); 324 330 write_header($1); ··· 327 333 write_client($1); 328 334 write_server($1); 329 335 write_regscript($1); 336 + #ifndef __REACTOS__ 337 + write_typelib_regscript($1); 338 + #endif 330 339 write_dlldata($1); 331 340 write_local_stubs($1); 332 341 } 333 342 ; 343 + 344 + m_acf: /* empty */ | aACF acf_statements 334 345 335 346 gbl_statements: { $$ = NULL; } 336 347 | gbl_statements namespacedef '{' { push_namespace($2); } gbl_statements '}' ··· 425 436 ; 426 437 427 438 importlib: tIMPORTLIB '(' aSTRING ')' 439 + /* ifdef __REACTOS__ */ 428 440 semicolon_opt { $$ = $3; if(!parse_only) add_importlib($3); } 441 + /* else 442 + semicolon_opt { $$ = $3; if(!parse_only) add_importlib($3, current_typelib); } 443 + */ 429 444 ; 430 445 431 446 libraryhdr: tLIBRARY aIDENTIFIER { $$ = $2; } 432 447 | tLIBRARY aKNOWNTYPE { $$ = $2; } 433 448 ; 434 449 library_start: attributes libraryhdr '{' { $$ = make_library($2, check_library_attrs($2, $1)); 450 + /* ifdef __REACTOS__ */ 435 451 if (!parse_only) start_typelib($$); 452 + /* else 453 + if (!parse_only && do_typelib) current_typelib = $$; 454 + */ 436 455 } 437 456 ; 438 457 librarydef: library_start imp_statements '}' 458 + /* ifdef __REACTOS__ */ 439 459 semicolon_opt { $$ = $1; 440 460 $$->stmts = $2; 441 461 if (!parse_only) end_typelib(); 442 462 } 463 + /* else 464 + semicolon_opt { $$ = $1; $$->stmts = $2; } 465 + */ 443 466 ; 444 467 445 468 m_args: { $$ = NULL; } ··· 468 491 ; 469 492 470 493 array: '[' expr ']' { $$ = $2; 471 - if (!$$->is_const) 472 - error_loc("array dimension is not an integer constant\n"); 494 + if (!$$->is_const || $$->cval <= 0) 495 + error_loc("array dimension is not a positive integer constant\n"); 473 496 } 474 497 | '[' '*' ']' { $$ = make_expr(EXPR_VOID); } 475 498 | '[' ']' { $$ = make_expr(EXPR_VOID); } ··· 816 839 int_std: tINT { $$ = type_new_int(TYPE_BASIC_INT, 0); } 817 840 | tSHORT m_int { $$ = type_new_int(TYPE_BASIC_INT16, 0); } 818 841 | tSMALL { $$ = type_new_int(TYPE_BASIC_INT8, 0); } 819 - | tLONG m_int { $$ = type_new_int(TYPE_BASIC_INT32, 0); } 842 + | tLONG m_int { $$ = type_new_int(TYPE_BASIC_LONG, 0); } 820 843 | tHYPER m_int { $$ = type_new_int(TYPE_BASIC_HYPER, 0); } 821 844 | tINT64 { $$ = type_new_int(TYPE_BASIC_INT64, 0); } 822 845 | tCHAR { $$ = type_new_int(TYPE_BASIC_CHAR, 0); } 846 + | tINT32 { $$ = type_new_int(TYPE_BASIC_INT32, 0); } 823 847 | tINT3264 { $$ = type_new_int(TYPE_BASIC_INT3264, 0); } 824 848 ; 825 849 ··· 909 933 if($$ == $2) 910 934 error_loc("Interface can't inherit from itself\n"); 911 935 type_interface_define($$, $2, $4); 936 + check_async_uuid($$); 912 937 pointer_default = $1.old_pointer_default; 913 938 } 914 939 /* MIDL is able to import the definition of a base class from inside the ··· 977 1002 978 1003 declarator: 979 1004 '*' m_type_qual_list declarator %prec PPTR 980 - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1005 + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 981 1006 | callconv declarator { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1)); 982 1007 else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } 983 1008 | direct_declarator ··· 986 1011 direct_declarator: 987 1012 ident { $$ = make_declarator($1); } 988 1013 | '(' declarator ')' { $$ = $2; } 989 - | direct_declarator array { $$ = $1; $$->array = append_array($$->array, $2); } 1014 + | direct_declarator array { $$ = $1; $$->type = append_array($$->type, $2); } 990 1015 | direct_declarator '(' m_args ')' { $$ = $1; 991 - $$->func_type = append_ptrchain_type($$->type, type_new_function($3)); 1016 + $$->func_type = append_chain_type($$->type, type_new_function($3)); 992 1017 $$->type = NULL; 993 1018 } 994 1019 ; ··· 996 1021 /* abstract declarator */ 997 1022 abstract_declarator: 998 1023 '*' m_type_qual_list m_abstract_declarator %prec PPTR 999 - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1024 + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1000 1025 | callconv m_abstract_declarator { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1)); 1001 1026 else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } 1002 1027 | abstract_direct_declarator ··· 1005 1030 /* abstract declarator without accepting direct declarator */ 1006 1031 abstract_declarator_no_direct: 1007 1032 '*' m_type_qual_list m_any_declarator %prec PPTR 1008 - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1033 + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1009 1034 | callconv m_any_declarator { $$ = $2; if ($$->func_type) $$->func_type->attrs = append_attr($$->func_type->attrs, make_attrp(ATTR_CALLCONV, $1)); 1010 1035 else if ($$->type) $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } 1011 1036 ; ··· 1018 1043 /* abstract direct declarator */ 1019 1044 abstract_direct_declarator: 1020 1045 '(' abstract_declarator_no_direct ')' { $$ = $2; } 1021 - | abstract_direct_declarator array { $$ = $1; $$->array = append_array($$->array, $2); } 1022 - | array { $$ = make_declarator(NULL); $$->array = append_array($$->array, $1); } 1046 + | abstract_direct_declarator array { $$ = $1; $$->type = append_array($$->type, $2); } 1047 + | array { $$ = make_declarator(NULL); $$->type = append_array($$->type, $1); } 1023 1048 | '(' m_args ')' 1024 1049 { $$ = make_declarator(NULL); 1025 - $$->func_type = append_ptrchain_type($$->type, type_new_function($2)); 1050 + $$->func_type = append_chain_type($$->type, type_new_function($2)); 1026 1051 $$->type = NULL; 1027 1052 } 1028 1053 | abstract_direct_declarator '(' m_args ')' 1029 1054 { $$ = $1; 1030 - $$->func_type = append_ptrchain_type($$->type, type_new_function($3)); 1055 + $$->func_type = append_chain_type($$->type, type_new_function($3)); 1031 1056 $$->type = NULL; 1032 1057 } 1033 1058 ; ··· 1035 1060 /* abstract or non-abstract declarator */ 1036 1061 any_declarator: 1037 1062 '*' m_type_qual_list m_any_declarator %prec PPTR 1038 - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1063 + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1039 1064 | callconv m_any_declarator { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } 1040 1065 | any_direct_declarator 1041 1066 ; ··· 1043 1068 /* abstract or non-abstract declarator without accepting direct declarator */ 1044 1069 any_declarator_no_direct: 1045 1070 '*' m_type_qual_list m_any_declarator %prec PPTR 1046 - { $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1071 + { $$ = $3; $$->type = append_chain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); } 1047 1072 | callconv m_any_declarator { $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); } 1048 1073 ; 1049 1074 ··· 1058 1083 any_direct_declarator: 1059 1084 ident { $$ = make_declarator($1); } 1060 1085 | '(' any_declarator_no_direct ')' { $$ = $2; } 1061 - | any_direct_declarator array { $$ = $1; $$->array = append_array($$->array, $2); } 1062 - | array { $$ = make_declarator(NULL); $$->array = append_array($$->array, $1); } 1086 + | any_direct_declarator array { $$ = $1; $$->type = append_array($$->type, $2); } 1087 + | array { $$ = make_declarator(NULL); $$->type = append_array($$->type, $1); } 1063 1088 | '(' m_args ')' 1064 1089 { $$ = make_declarator(NULL); 1065 - $$->func_type = append_ptrchain_type($$->type, type_new_function($2)); 1090 + $$->func_type = append_chain_type($$->type, type_new_function($2)); 1066 1091 $$->type = NULL; 1067 1092 } 1068 1093 | any_direct_declarator '(' m_args ')' 1069 1094 { $$ = $1; 1070 - $$->func_type = append_ptrchain_type($$->type, type_new_function($3)); 1095 + $$->func_type = append_chain_type($$->type, type_new_function($3)); 1071 1096 $$->type = NULL; 1072 1097 } 1073 1098 ; ··· 1107 1132 ; 1108 1133 1109 1134 pointer_type: 1110 - tREF { $$ = RPC_FC_RP; } 1111 - | tUNIQUE { $$ = RPC_FC_UP; } 1112 - | tPTR { $$ = RPC_FC_FP; } 1135 + tREF { $$ = FC_RP; } 1136 + | tUNIQUE { $$ = FC_UP; } 1137 + | tPTR { $$ = FC_FP; } 1113 1138 ; 1114 1139 1115 1140 structdef: tSTRUCT t_ident '{' fields '}' { $$ = type_new_struct($2, current_namespace, TRUE, $4); } ··· 1147 1172 | aHEXNUM { $$ = $1; } 1148 1173 ; 1149 1174 1175 + acf_statements 1176 + : /* empty */ 1177 + | acf_interface acf_statements 1178 + 1179 + acf_int_statements 1180 + : /* empty */ 1181 + | acf_int_statement acf_int_statements 1182 + 1183 + acf_int_statement 1184 + : tTYPEDEF acf_attributes aKNOWNTYPE ';' 1185 + { type_t *type = find_type_or_error($3, 0); 1186 + type->attrs = append_attr_list(type->attrs, $2); 1187 + } 1188 + acf_interface 1189 + : acf_attributes tINTERFACE aKNOWNTYPE '{' acf_int_statements '}' 1190 + { type_t *iface = find_type_or_error2($3, 0); 1191 + if (type_get_type(iface) != TYPE_INTERFACE) 1192 + error_loc("%s is not an interface\n", iface->name); 1193 + iface->attrs = append_attr_list(iface->attrs, $1); 1194 + } 1195 + 1196 + acf_attributes 1197 + : /* empty */ { $$ = NULL; }; 1198 + | '[' acf_attribute_list ']' { $$ = $2; }; 1199 + 1200 + acf_attribute_list 1201 + : acf_attribute { $$ = append_attr(NULL, $1); } 1202 + | acf_attribute_list ',' acf_attribute { $$ = append_attr($1, $3); } 1203 + 1204 + acf_attribute 1205 + : tENCODE { $$ = make_attr(ATTR_ENCODE); } 1206 + | tDECODE { $$ = make_attr(ATTR_DECODE); } 1207 + | tEXPLICITHANDLE { $$ = make_attr(ATTR_EXPLICIT_HANDLE); } 1208 + 1150 1209 %% 1151 1210 1152 1211 static void decl_builtin_basic(const char *name, enum type_basic_type type) ··· 1236 1295 return new_list; 1237 1296 } 1238 1297 1239 - static attr_list_t *dupattrs(const attr_list_t *list) 1298 + typedef int (*map_attrs_filter_t)(attr_list_t*,const attr_t*); 1299 + 1300 + static attr_list_t *map_attrs(const attr_list_t *list, map_attrs_filter_t filter) 1240 1301 { 1241 1302 attr_list_t *new_list; 1242 1303 const attr_t *attr; 1304 + attr_t *new_attr; 1243 1305 1244 1306 if (!list) return NULL; 1245 1307 ··· 1247 1309 list_init( new_list ); 1248 1310 LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry) 1249 1311 { 1250 - attr_t *new_attr = xmalloc(sizeof(*new_attr)); 1312 + if (filter && !filter(new_list, attr)) continue; 1313 + new_attr = xmalloc(sizeof(*new_attr)); 1251 1314 *new_attr = *attr; 1252 1315 list_add_tail(new_list, &new_attr->entry); 1253 1316 } ··· 1297 1360 { 1298 1361 attr_list_t *attrs; 1299 1362 declspec->type = duptype(type, 1); 1300 - attrs = dupattrs(type->attrs); 1363 + attrs = map_attrs(type->attrs, NULL); 1301 1364 declspec->type->attrs = append_attr_list(attrs, declspec->attrs); 1302 1365 declspec->attrs = NULL; 1303 1366 } ··· 1341 1404 return list; 1342 1405 } 1343 1406 1344 - static array_dims_t *append_array(array_dims_t *list, expr_t *expr) 1407 + static type_t *append_array(type_t *chain, expr_t *expr) 1345 1408 { 1346 - if (!expr) return list; 1347 - if (!list) 1348 - { 1349 - list = xmalloc( sizeof(*list) ); 1350 - list_init( list ); 1351 - } 1352 - list_add_tail( list, &expr->entry ); 1353 - return list; 1409 + type_t *array; 1410 + 1411 + if (!expr) 1412 + return chain; 1413 + 1414 + /* An array is always a reference pointer unless explicitly marked otherwise 1415 + * (regardless of what the default pointer attribute is). */ 1416 + array = type_new_array(NULL, NULL, FALSE, expr->is_const ? expr->cval : 0, 1417 + expr->is_const ? NULL : expr, NULL, FC_RP); 1418 + 1419 + return append_chain_type(chain, array); 1354 1420 } 1355 1421 1356 1422 static struct list type_pool = LIST_INIT(type_pool); ··· 1406 1472 case TYPE_BASIC_INT64: 1407 1473 case TYPE_BASIC_INT: 1408 1474 case TYPE_BASIC_INT3264: 1475 + case TYPE_BASIC_LONG: 1409 1476 case TYPE_BASIC_BYTE: 1410 1477 case TYPE_BASIC_CHAR: 1411 1478 case TYPE_BASIC_WCHAR: ··· 1423 1490 } 1424 1491 } 1425 1492 1426 - static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type) 1493 + static type_t *get_array_or_ptr_ref(type_t *type) 1427 1494 { 1428 - type_t *ptrchain_type; 1429 - if (!ptrchain) 1430 - return type; 1431 - for (ptrchain_type = ptrchain; type_pointer_get_ref(ptrchain_type); ptrchain_type = type_pointer_get_ref(ptrchain_type)) 1432 - ; 1433 - assert(ptrchain_type->type_type == TYPE_POINTER); 1434 - ptrchain_type->details.pointer.ref = type; 1435 - return ptrchain; 1495 + if (is_ptr(type)) 1496 + return type_pointer_get_ref(type); 1497 + else if (is_array(type)) 1498 + return type_array_get_element(type); 1499 + return NULL; 1500 + } 1501 + 1502 + static type_t *append_chain_type(type_t *chain, type_t *type) 1503 + { 1504 + type_t *chain_type; 1505 + 1506 + if (!chain) 1507 + return type; 1508 + for (chain_type = chain; get_array_or_ptr_ref(chain_type); chain_type = get_array_or_ptr_ref(chain_type)) 1509 + ; 1510 + 1511 + if (is_ptr(chain_type)) 1512 + chain_type->details.pointer.ref = type; 1513 + else if (is_array(chain_type)) 1514 + chain_type->details.array.elem = type; 1515 + else 1516 + assert(0); 1517 + 1518 + return chain; 1436 1519 } 1437 1520 1438 1521 static warning_list_t *append_warning(warning_list_t *list, int num) ··· 1456 1539 var_t *v = decl->var; 1457 1540 expr_list_t *sizes = get_attrp(attrs, ATTR_SIZEIS); 1458 1541 expr_list_t *lengs = get_attrp(attrs, ATTR_LENGTHIS); 1459 - int sizeless; 1460 1542 expr_t *dim; 1461 1543 type_t **ptype; 1462 - array_dims_t *arr = decl ? decl->array : NULL; 1463 1544 type_t *func_type = decl ? decl->func_type : NULL; 1464 1545 type_t *type = decl_spec->type; 1465 1546 ··· 1478 1559 } 1479 1560 1480 1561 /* add type onto the end of the pointers in pident->type */ 1481 - v->type = append_ptrchain_type(decl ? decl->type : NULL, type); 1562 + v->type = append_chain_type(decl ? decl->type : NULL, type); 1482 1563 v->stgclass = decl_spec->stgclass; 1483 1564 v->attrs = attrs; 1484 1565 1485 1566 /* check for pointer attribute being applied to non-pointer, non-array 1486 1567 * type */ 1487 - if (!arr) 1568 + if (!is_array(v->type)) 1488 1569 { 1489 1570 int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE); 1490 1571 const type_t *ptr = NULL; ··· 1501 1582 } 1502 1583 if (is_ptr(ptr)) 1503 1584 { 1504 - if (ptr_attr && ptr_attr != RPC_FC_UP && 1585 + if (ptr_attr && ptr_attr != FC_UP && 1505 1586 type_get_type(type_pointer_get_ref(ptr)) == TYPE_INTERFACE) 1506 1587 warning_loc_info(&v->loc_info, 1507 1588 "%s: pointer attribute applied to interface " 1508 1589 "pointer type has no effect\n", v->name); 1509 - if (!ptr_attr && top && (*pt)->details.pointer.def_fc != RPC_FC_RP) 1590 + if (!ptr_attr && top && (*pt)->details.pointer.def_fc != FC_RP) 1510 1591 { 1511 1592 /* FIXME: this is a horrible hack to cope with the issue that we 1512 1593 * store an offset to the typeformat string in the type object, but ··· 1523 1604 { 1524 1605 type_t *t = type; 1525 1606 1526 - if (!is_ptr(v->type) && !arr) 1607 + if (!is_ptr(v->type) && !is_array(v->type)) 1527 1608 error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n", 1528 1609 v->name); 1529 1610 1530 - while (is_ptr(t)) 1531 - t = type_pointer_get_ref(t); 1611 + for (;;) 1612 + { 1613 + if (is_ptr(t)) 1614 + t = type_pointer_get_ref(t); 1615 + else if (is_array(t)) 1616 + t = type_array_get_element(t); 1617 + else 1618 + break; 1619 + } 1532 1620 1533 1621 if (type_get_type(t) != TYPE_BASIC && 1534 - (get_basic_fc(t) != RPC_FC_CHAR && 1535 - get_basic_fc(t) != RPC_FC_BYTE && 1536 - get_basic_fc(t) != RPC_FC_WCHAR)) 1622 + (get_basic_fc(t) != FC_CHAR && 1623 + get_basic_fc(t) != FC_BYTE && 1624 + get_basic_fc(t) != FC_WCHAR)) 1537 1625 { 1538 1626 error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n", 1539 1627 v->name); ··· 1551 1639 v->name); 1552 1640 1553 1641 ptype = &v->type; 1554 - sizeless = FALSE; 1555 - if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry) 1556 - { 1557 - if (sizeless) 1558 - error_loc("%s: only the first array dimension can be unspecified\n", v->name); 1559 - 1560 - if (dim->is_const) 1561 - { 1562 - if (dim->cval <= 0) 1563 - error_loc("%s: array dimension must be positive\n", v->name); 1564 - 1565 - /* FIXME: should use a type_memsize that allows us to pass in a pointer size */ 1566 - if (0) 1567 - { 1568 - unsigned int size = type_memsize(v->type); 1569 - 1570 - if (0xffffffffu / size < dim->cval) 1571 - error_loc("%s: total array size is too large\n", v->name); 1572 - } 1573 - } 1574 - else 1575 - sizeless = TRUE; 1576 - 1577 - *ptype = type_new_array(NULL, *ptype, FALSE, 1578 - dim->is_const ? dim->cval : 0, 1579 - dim->is_const ? NULL : dim, NULL, 1580 - pointer_default); 1581 - } 1582 - 1583 - ptype = &v->type; 1584 1642 if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry) 1585 1643 { 1586 1644 if (dim->type != EXPR_VOID) ··· 1739 1797 return v; 1740 1798 } 1741 1799 1800 + static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter) 1801 + { 1802 + var_t *v = xmalloc(sizeof(var_t)); 1803 + v->name = name; 1804 + v->type = src->type; 1805 + v->attrs = map_attrs(src->attrs, attr_filter); 1806 + v->eval = src->eval; 1807 + v->stgclass = src->stgclass; 1808 + v->loc_info = src->loc_info; 1809 + return v; 1810 + } 1811 + 1742 1812 static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d) 1743 1813 { 1744 1814 if (!d) return list; ··· 1756 1826 d->var = var ? var : make_var(NULL); 1757 1827 d->type = NULL; 1758 1828 d->func_type = NULL; 1759 - d->array = NULL; 1760 1829 d->bits = NULL; 1761 1830 return d; 1762 1831 } ··· 1764 1833 static type_t *make_safearray(type_t *type) 1765 1834 { 1766 1835 return type_new_array(NULL, type_new_alias(type, "SAFEARRAY"), TRUE, 0, 1767 - NULL, NULL, RPC_FC_RP); 1836 + NULL, NULL, FC_RP); 1768 1837 } 1769 1838 1770 1839 static typelib_t *make_library(const char *name, const attr_list_t *attrs) ··· 2415 2484 case TYPE_BASIC_INT32: 2416 2485 case TYPE_BASIC_INT64: 2417 2486 case TYPE_BASIC_INT: 2487 + case TYPE_BASIC_LONG: 2418 2488 case TYPE_BASIC_CHAR: 2419 2489 case TYPE_BASIC_HYPER: 2420 2490 case TYPE_BASIC_BYTE: ··· 2753 2823 check_remoting_args(func); 2754 2824 } 2755 2825 } 2826 + } 2827 + 2828 + static char *concat_str(const char *prefix, const char *str) 2829 + { 2830 + char *ret = xmalloc(strlen(prefix) + strlen(str) + 1); 2831 + strcpy(ret, prefix); 2832 + strcat(ret, str); 2833 + return ret; 2834 + } 2835 + 2836 + static int async_iface_attrs(attr_list_t *attrs, const attr_t *attr) 2837 + { 2838 + switch(attr->type) 2839 + { 2840 + case ATTR_UUID: 2841 + return 0; 2842 + case ATTR_ASYNCUUID: 2843 + append_attr(attrs, make_attrp(ATTR_UUID, attr->u.pval)); 2844 + return 0; 2845 + default: 2846 + return 1; 2847 + } 2848 + } 2849 + 2850 + static int arg_in_attrs(attr_list_t *attrs, const attr_t *attr) 2851 + { 2852 + return attr->type != ATTR_OUT && attr->type != ATTR_RETVAL; 2853 + } 2854 + 2855 + static int arg_out_attrs(attr_list_t *attrs, const attr_t *attr) 2856 + { 2857 + return attr->type != ATTR_IN; 2858 + } 2859 + 2860 + static void check_async_uuid(type_t *iface) 2861 + { 2862 + statement_list_t *stmts = NULL; 2863 + statement_t *stmt; 2864 + type_t *async_iface; 2865 + type_t *inherit; 2866 + 2867 + if (!is_attr(iface->attrs, ATTR_ASYNCUUID)) return; 2868 + 2869 + inherit = iface->details.iface->inherit; 2870 + if (inherit && strcmp(inherit->name, "IUnknown")) 2871 + inherit = inherit->details.iface->async_iface; 2872 + if (!inherit) 2873 + error_loc("async_uuid applied to an interface with incompatible parent\n"); 2874 + 2875 + async_iface = get_type(TYPE_INTERFACE, concat_str("Async", iface->name), iface->namespace, 0); 2876 + async_iface->attrs = map_attrs(iface->attrs, async_iface_attrs); 2877 + 2878 + STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) 2879 + { 2880 + var_t *begin_func, *finish_func, *func = stmt->u.var, *arg; 2881 + var_list_t *begin_args = NULL, *finish_args = NULL, *args; 2882 + 2883 + args = func->type->details.function->args; 2884 + if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry) 2885 + { 2886 + if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT)) 2887 + begin_args = append_var(begin_args, copy_var(arg, strdup(arg->name), arg_in_attrs)); 2888 + if (is_attr(arg->attrs, ATTR_OUT)) 2889 + finish_args = append_var(finish_args, copy_var(arg, strdup(arg->name), arg_out_attrs)); 2890 + } 2891 + 2892 + begin_func = copy_var(func, concat_str("Begin_", func->name), NULL); 2893 + begin_func->type = type_new_function(begin_args); 2894 + begin_func->type->attrs = func->attrs; 2895 + begin_func->type->details.function->retval = func->type->details.function->retval; 2896 + stmts = append_statement(stmts, make_statement_declaration(begin_func)); 2897 + 2898 + finish_func = copy_var(func, concat_str("Finish_", func->name), NULL); 2899 + finish_func->type = type_new_function(finish_args); 2900 + finish_func->type->attrs = func->attrs; 2901 + finish_func->type->details.function->retval = func->type->details.function->retval; 2902 + stmts = append_statement(stmts, make_statement_declaration(finish_func)); 2903 + } 2904 + 2905 + type_interface_define(async_iface, inherit, stmts); 2906 + iface->details.iface->async_iface = async_iface->details.iface->async_iface = async_iface; 2756 2907 } 2757 2908 2758 2909 static void check_statements(const statement_list_t *stmts, int is_inside_library)
+90 -50
sdk/tools/widl/parser.yy.c
··· 764 764 static int kw_token(const char *kw); 765 765 static int attr_token(const char *kw); 766 766 767 + static void switch_to_acf(void); 768 + 767 769 static warning_list_t *disabled_warnings = NULL; 768 770 769 771 #define MAX_IMPORT_DEPTH 20 ··· 813 815 * The flexer starts here 814 816 ************************************************************************** 815 817 */ 816 - #line 817 "parser.yy.c" 818 + #line 819 "parser.yy.c" 817 819 818 820 #define INITIAL 0 819 821 #define QUOTE 1 ··· 1010 1012 register char *yy_cp, *yy_bp; 1011 1013 register int yy_act; 1012 1014 1013 - #line 130 "parser.l" 1015 + #line 132 "parser.l" 1014 1016 1015 - #line 1016 "parser.yy.c" 1017 + #line 1018 "parser.yy.c" 1016 1018 1017 1019 if ( !(yy_init) ) 1018 1020 { ··· 1094 1096 1095 1097 case 1: 1096 1098 YY_RULE_SETUP 1097 - #line 131 "parser.l" 1099 + #line 133 "parser.l" 1098 1100 yy_push_state(PP_PRAGMA); 1099 1101 YY_BREAK 1100 1102 case 2: 1101 1103 YY_RULE_SETUP 1102 - #line 132 "parser.l" 1104 + #line 134 "parser.l" 1103 1105 yy_push_state(PP_LINE); 1104 1106 YY_BREAK 1105 1107 case 3: 1106 1108 YY_RULE_SETUP 1107 - #line 133 "parser.l" 1109 + #line 135 "parser.l" 1108 1110 { 1109 1111 int lineno; 1110 1112 char *cptr, *fname; ··· 1126 1128 YY_BREAK 1127 1129 case 4: 1128 1130 YY_RULE_SETUP 1129 - #line 151 "parser.l" 1131 + #line 153 "parser.l" 1130 1132 yyless(9); yy_pop_state(); return tCPPQUOTE; 1131 1133 YY_BREAK 1132 1134 case 5: 1133 1135 YY_RULE_SETUP 1134 - #line 152 "parser.l" 1136 + #line 154 "parser.l" 1135 1137 { 1136 1138 if(import_stack_ptr) { 1137 1139 if(!winrt_mode) ··· 1151 1153 YY_BREAK 1152 1154 case 6: 1153 1155 YY_RULE_SETUP 1154 - #line 168 "parser.l" 1156 + #line 170 "parser.l" 1155 1157 parser_lval.str = xstrdup(parser_text); yy_pop_state(); return aPRAGMA; 1156 1158 YY_BREAK 1157 1159 case 7: 1158 1160 YY_RULE_SETUP 1159 - #line 169 "parser.l" 1161 + #line 171 "parser.l" 1160 1162 return tPRAGMA_WARNING; 1161 1163 YY_BREAK 1162 1164 case 8: 1163 1165 YY_RULE_SETUP 1164 - #line 170 "parser.l" 1166 + #line 172 "parser.l" 1165 1167 yy_push_state(QUOTE); cbufidx = 0; 1166 1168 YY_BREAK 1167 1169 case 9: 1168 1170 YY_RULE_SETUP 1169 - #line 171 "parser.l" 1171 + #line 173 "parser.l" 1170 1172 { 1171 1173 yy_pop_state(); 1172 1174 parser_lval.str = get_buffered_cstring(); ··· 1175 1177 YY_BREAK 1176 1178 case 10: 1177 1179 YY_RULE_SETUP 1178 - #line 176 "parser.l" 1180 + #line 178 "parser.l" 1179 1181 yy_push_state(WSTRQUOTE); cbufidx = 0; 1180 1182 YY_BREAK 1181 1183 case 11: 1182 1184 YY_RULE_SETUP 1183 - #line 177 "parser.l" 1185 + #line 179 "parser.l" 1184 1186 { 1185 1187 yy_pop_state(); 1186 1188 parser_lval.str = get_buffered_cstring(); ··· 1189 1191 YY_BREAK 1190 1192 case 12: 1191 1193 YY_RULE_SETUP 1192 - #line 182 "parser.l" 1194 + #line 184 "parser.l" 1193 1195 yy_push_state(SQUOTE); cbufidx = 0; 1194 1196 YY_BREAK 1195 1197 case 13: 1196 1198 YY_RULE_SETUP 1197 - #line 183 "parser.l" 1199 + #line 185 "parser.l" 1198 1200 { 1199 1201 yy_pop_state(); 1200 1202 parser_lval.str = get_buffered_cstring(); ··· 1202 1204 } 1203 1205 YY_BREAK 1204 1206 case 14: 1205 - #line 189 "parser.l" 1207 + #line 191 "parser.l" 1206 1208 case 15: 1207 1209 YY_RULE_SETUP 1208 - #line 189 "parser.l" 1210 + #line 191 "parser.l" 1209 1211 addcchar(parser_text[1]); 1210 1212 YY_BREAK 1211 1213 case 16: 1212 1214 YY_RULE_SETUP 1213 - #line 190 "parser.l" 1215 + #line 192 "parser.l" 1214 1216 addcchar(parser_text[1]); 1215 1217 YY_BREAK 1216 1218 case 17: 1217 1219 YY_RULE_SETUP 1218 - #line 191 "parser.l" 1220 + #line 193 "parser.l" 1219 1221 addcchar('\\'); addcchar(parser_text[1]); 1220 1222 YY_BREAK 1221 1223 case 18: 1222 1224 YY_RULE_SETUP 1223 - #line 192 "parser.l" 1225 + #line 194 "parser.l" 1224 1226 addcchar(parser_text[0]); 1225 1227 YY_BREAK 1226 1228 case 19: 1227 1229 YY_RULE_SETUP 1228 - #line 193 "parser.l" 1230 + #line 195 "parser.l" 1229 1231 yy_push_state(ATTR); return '['; 1230 1232 YY_BREAK 1231 1233 case 20: 1232 1234 YY_RULE_SETUP 1233 - #line 194 "parser.l" 1235 + #line 196 "parser.l" 1234 1236 yy_pop_state(); return ']'; 1235 1237 YY_BREAK 1236 1238 case 21: 1237 1239 YY_RULE_SETUP 1238 - #line 195 "parser.l" 1240 + #line 197 "parser.l" 1239 1241 return attr_token(parser_text); 1240 1242 YY_BREAK 1241 1243 case 22: 1242 1244 YY_RULE_SETUP 1243 - #line 196 "parser.l" 1245 + #line 198 "parser.l" 1244 1246 { 1245 1247 parser_lval.uuid = parse_uuid(parser_text); 1246 1248 return aUUID; ··· 1248 1250 YY_BREAK 1249 1251 case 23: 1250 1252 YY_RULE_SETUP 1251 - #line 200 "parser.l" 1253 + #line 202 "parser.l" 1252 1254 { 1253 1255 parser_lval.num = xstrtoul(parser_text, NULL, 0); 1254 1256 return aHEXNUM; ··· 1256 1258 YY_BREAK 1257 1259 case 24: 1258 1260 YY_RULE_SETUP 1259 - #line 204 "parser.l" 1261 + #line 206 "parser.l" 1260 1262 { 1261 1263 parser_lval.num = xstrtoul(parser_text, NULL, 0); 1262 1264 return aNUM; ··· 1264 1266 YY_BREAK 1265 1267 case 25: 1266 1268 YY_RULE_SETUP 1267 - #line 208 "parser.l" 1269 + #line 210 "parser.l" 1268 1270 { 1269 1271 parser_lval.dbl = strtod(parser_text, NULL); 1270 1272 return aDOUBLE; ··· 1275 1277 (yy_c_buf_p) = yy_cp -= 1; 1276 1278 YY_DO_BEFORE_ACTION; /* set up parser_text again */ 1277 1279 YY_RULE_SETUP 1278 - #line 212 "parser.l" 1280 + #line 214 "parser.l" 1279 1281 return tSAFEARRAY; 1280 1282 YY_BREAK 1281 1283 case 27: 1282 1284 YY_RULE_SETUP 1283 - #line 213 "parser.l" 1285 + #line 215 "parser.l" 1284 1286 return kw_token(parser_text); 1285 1287 YY_BREAK 1286 1288 case 28: 1287 1289 /* rule 28 can match eol */ 1288 1290 YY_RULE_SETUP 1289 - #line 214 "parser.l" 1291 + #line 216 "parser.l" 1290 1292 line_number++; 1291 1293 YY_BREAK 1292 1294 case 29: 1293 1295 YY_RULE_SETUP 1294 - #line 215 "parser.l" 1296 + #line 217 "parser.l" 1295 1297 1296 1298 YY_BREAK 1297 1299 case 30: 1298 1300 YY_RULE_SETUP 1299 - #line 216 "parser.l" 1301 + #line 218 "parser.l" 1300 1302 return SHL; 1301 1303 YY_BREAK 1302 1304 case 31: 1303 1305 YY_RULE_SETUP 1304 - #line 217 "parser.l" 1306 + #line 219 "parser.l" 1305 1307 return SHR; 1306 1308 YY_BREAK 1307 1309 case 32: 1308 1310 YY_RULE_SETUP 1309 - #line 218 "parser.l" 1311 + #line 220 "parser.l" 1310 1312 return MEMBERPTR; 1311 1313 YY_BREAK 1312 1314 case 33: 1313 1315 YY_RULE_SETUP 1314 - #line 219 "parser.l" 1316 + #line 221 "parser.l" 1315 1317 return EQUALITY; 1316 1318 YY_BREAK 1317 1319 case 34: 1318 1320 YY_RULE_SETUP 1319 - #line 220 "parser.l" 1321 + #line 222 "parser.l" 1320 1322 return INEQUALITY; 1321 1323 YY_BREAK 1322 1324 case 35: 1323 1325 YY_RULE_SETUP 1324 - #line 221 "parser.l" 1326 + #line 223 "parser.l" 1325 1327 return GREATEREQUAL; 1326 1328 YY_BREAK 1327 1329 case 36: 1328 1330 YY_RULE_SETUP 1329 - #line 222 "parser.l" 1331 + #line 224 "parser.l" 1330 1332 return LESSEQUAL; 1331 1333 YY_BREAK 1332 1334 case 37: 1333 1335 YY_RULE_SETUP 1334 - #line 223 "parser.l" 1336 + #line 225 "parser.l" 1335 1337 return LOGICALOR; 1336 1338 YY_BREAK 1337 1339 case 38: 1338 1340 YY_RULE_SETUP 1339 - #line 224 "parser.l" 1341 + #line 226 "parser.l" 1340 1342 return LOGICALAND; 1341 1343 YY_BREAK 1342 1344 case 39: 1343 1345 YY_RULE_SETUP 1344 - #line 225 "parser.l" 1346 + #line 227 "parser.l" 1345 1347 return ELLIPSIS; 1346 1348 YY_BREAK 1347 1349 case 40: 1348 1350 YY_RULE_SETUP 1349 - #line 226 "parser.l" 1351 + #line 228 "parser.l" 1350 1352 return parser_text[0]; 1351 1353 YY_BREAK 1352 1354 case YY_STATE_EOF(INITIAL): ··· 1356 1358 case YY_STATE_EOF(PP_LINE): 1357 1359 case YY_STATE_EOF(PP_PRAGMA): 1358 1360 case YY_STATE_EOF(SQUOTE): 1359 - #line 227 "parser.l" 1361 + #line 229 "parser.l" 1360 1362 { 1361 - if (import_stack_ptr) 1362 - return aEOF; 1363 - else yyterminate(); 1363 + if (import_stack_ptr) 1364 + return aEOF; 1365 + if (acf_name) 1366 + { 1367 + switch_to_acf(); 1368 + return aACF; 1369 + } 1370 + yyterminate(); 1364 1371 } 1365 1372 YY_BREAK 1366 1373 case 41: 1367 1374 YY_RULE_SETUP 1368 - #line 232 "parser.l" 1375 + #line 239 "parser.l" 1369 1376 ECHO; 1370 1377 YY_BREAK 1371 - #line 1372 "parser.yy.c" 1378 + #line 1379 "parser.yy.c" 1372 1379 1373 1380 case YY_END_OF_BUFFER: 1374 1381 { ··· 2367 2374 2368 2375 #define YYTABLES_NAME "yytables" 2369 2376 2370 - #line 231 "parser.l" 2377 + #line 238 "parser.l" 2371 2378 2372 2379 2373 2380 ··· 2390 2397 {"TRUE", tTRUE}, 2391 2398 {"__cdecl", tCDECL}, 2392 2399 {"__fastcall", tFASTCALL}, 2400 + {"__int32", tINT32}, 2393 2401 {"__int3264", tINT3264}, 2394 2402 {"__int64", tINT64}, 2395 2403 {"__pascal", tPASCAL}, ··· 2700 2708 2701 2709 for (ptr=0; ptr<import_stack_ptr; ptr++) 2702 2710 unlink(import_stack[ptr].temp_name); 2711 + } 2712 + 2713 + static void switch_to_acf(void) 2714 + { 2715 + int ptr = import_stack_ptr; 2716 + int ret, fd; 2717 + char *name; 2718 + FILE *f; 2719 + 2720 + assert(import_stack_ptr == 0); 2721 + 2722 + input_name = acf_name; 2723 + acf_name = NULL; 2724 + line_number = 1; 2725 + 2726 + name = xstrdup( "widl.XXXXXX" ); 2727 + if((fd = mkstemps( name, 0 )) == -1) 2728 + error("Could not generate a temp name from %s\n", name); 2729 + 2730 + temp_name = name; 2731 + if (!(f = fdopen(fd, "wt"))) 2732 + error("Could not open fd %s for writing\n", name); 2733 + 2734 + ret = wpp_parse(input_name, f); 2735 + fclose(f); 2736 + if (ret) exit(1); 2737 + 2738 + if((f = fopen(temp_name, "r")) == NULL) 2739 + error_loc("Unable to open %s\n", temp_name); 2740 + 2741 + import_stack[ptr].state = YY_CURRENT_BUFFER; 2742 + parser__switch_to_buffer(parser__create_buffer(f,YY_BUF_SIZE)); 2703 2743 } 2704 2744 2705 2745 static void warning_disable(int warning)
+1 -1
sdk/tools/widl/parser.yy.h
··· 317 317 #undef YY_DECL 318 318 #endif 319 319 320 - #line 231 "parser.l" 320 + #line 238 "parser.l" 321 321 322 322 323 323 #line 324 "parser.yy.h"
+51 -30
sdk/tools/widl/proxy.c
··· 116 116 if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_BASIC) continue; 117 117 if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_ENUM) continue; 118 118 } 119 - print_proxy( "if (%s) MIDL_memset( %s, 0, sizeof( *%s ));\n", arg->name, arg->name, arg->name ); 119 + print_proxy( "if (%s) MIDL_memset( %s, 0, ", arg->name, arg->name ); 120 + if (is_array(arg->type) && type_array_has_conformance(arg->type)) 121 + { 122 + write_expr( proxy, type_array_get_conformance(arg->type), 1, 1, NULL, NULL, "" ); 123 + fprintf( proxy, " * " ); 124 + } 125 + fprintf( proxy, "sizeof( *%s ));\n", arg->name ); 120 126 } 121 127 } 122 128 ··· 158 164 break; 159 165 160 166 case TGT_STRUCT: 161 - if (get_struct_fc(type) != RPC_FC_STRUCT) 167 + if (get_struct_fc(type) != FC_STRUCT) 162 168 print_proxy("/* FIXME: %s code for %s struct type 0x%x missing */\n", __FUNCTION__, arg->name, get_struct_fc(type) ); 163 169 break; 164 170 ··· 680 686 681 687 /* proxy vtable */ 682 688 print_proxy( "static %sCINTERFACE_PROXY_VTABLE(%d) _%sProxyVtbl =\n", 683 - need_delegation_indirect(iface) ? "" : "const ", count, iface->name); 689 + (get_stub_mode() != MODE_Os || need_delegation_indirect(iface)) ? "" : "const ", 690 + count, iface->name); 684 691 print_proxy( "{\n"); 685 692 indent++; 686 693 print_proxy( "{\n"); ··· 759 766 print_proxy( "},\n"); 760 767 print_proxy( "{\n"); 761 768 indent++; 762 - print_proxy( "CStdStubBuffer_%s\n", need_delegation_indirect(iface) ? "DELEGATING_METHODS" : "METHODS"); 769 + print_proxy( "%s_%s\n", 770 + iface->details.iface->async_iface == iface ? "CStdAsyncStubBuffer" : "CStdStubBuffer", 771 + need_delegation_indirect(iface) ? "DELEGATING_METHODS" : "METHODS"); 763 772 indent--; 764 773 print_proxy( "}\n"); 765 774 indent--; ··· 855 864 { 856 865 if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) 857 866 { 858 - if (need_proxy(stmt->u.type)) 859 - write_proxy(stmt->u.type, proc_offset); 867 + type_t *iface = stmt->u.type; 868 + if (need_proxy(iface)) 869 + { 870 + write_proxy(iface, proc_offset); 871 + if (iface->details.iface->async_iface) 872 + write_proxy(iface->details.iface->async_iface, proc_offset); 873 + } 860 874 } 861 875 } 862 876 } ··· 884 898 { 885 899 *ifaces = xrealloc( *ifaces, (*count + 1) * sizeof(**ifaces) ); 886 900 (*ifaces)[(*count)++] = iface; 901 + if (iface->details.iface->async_iface) 902 + { 903 + iface = iface->details.iface->async_iface; 904 + *ifaces = xrealloc( *ifaces, (*count + 1) * sizeof(**ifaces) ); 905 + (*ifaces)[(*count)++] = iface; 906 + } 887 907 } 888 908 } 889 909 } ··· 905 925 unsigned int proc_offset = 0; 906 926 char *file_id = proxy_token; 907 927 int i, count, have_baseiid = 0; 928 + unsigned int table_version; 908 929 type_t **interfaces; 909 930 const type_t * delegate_to; 910 931 ··· 950 971 write_stubdesc(expr_eval_routines); 951 972 952 973 print_proxy( "#if !defined(__RPC_WIN%u__)\n", pointer_size == 8 ? 64 : 32); 953 - print_proxy( "#error Currently only Wine and WIN32 are supported.\n"); 974 + print_proxy( "#error Invalid build platform for this proxy.\n"); 954 975 print_proxy( "#endif\n"); 955 976 print_proxy( "\n"); 956 977 write_procformatstring(proxy, stmts, need_proxy); ··· 1016 1037 fprintf(proxy, "}\n"); 1017 1038 fprintf(proxy, "\n"); 1018 1039 1040 + table_version = get_stub_mode() == MODE_Oif ? 2 : 1; 1041 + for (i = 0; i < count; i++) 1042 + { 1043 + if (interfaces[i]->details.iface->async_iface != interfaces[i]) continue; 1044 + if (table_version != 6) 1045 + { 1046 + fprintf(proxy, "static const IID *_AsyncInterfaceTable[] =\n"); 1047 + fprintf(proxy, "{\n"); 1048 + table_version = 6; 1049 + } 1050 + fprintf(proxy, " &IID_%s,\n", interfaces[i]->name); 1051 + fprintf(proxy, " (IID*)(LONG_PTR)-1,\n"); 1052 + } 1053 + if (table_version == 6) 1054 + { 1055 + fprintf(proxy, " 0\n"); 1056 + fprintf(proxy, "};\n"); 1057 + fprintf(proxy, "\n"); 1058 + } 1059 + 1019 1060 fprintf(proxy, "const ExtendedProxyFileInfo %s_ProxyFileInfo DECLSPEC_HIDDEN =\n", file_id); 1020 1061 fprintf(proxy, "{\n"); 1021 1062 fprintf(proxy, " (const PCInterfaceProxyVtblList*)_%s_ProxyVtblList,\n", file_id); ··· 1025 1066 else fprintf(proxy, " 0,\n"); 1026 1067 fprintf(proxy, " _%s_IID_Lookup,\n", file_id); 1027 1068 fprintf(proxy, " %d,\n", count); 1028 - fprintf(proxy, " %d,\n", get_stub_mode() == MODE_Oif ? 2 : 1); 1029 - fprintf(proxy, " 0,\n"); 1069 + fprintf(proxy, " %u,\n", table_version); 1070 + fprintf(proxy, " %s,\n", table_version == 6 ? "_AsyncInterfaceTable" : "0"); 1030 1071 fprintf(proxy, " 0,\n"); 1031 1072 fprintf(proxy, " 0,\n"); 1032 1073 fprintf(proxy, " 0\n"); ··· 1041 1082 init_proxy(stmts); 1042 1083 if(!proxy) return; 1043 1084 1044 - if (do_win32 && do_win64) 1045 - { 1046 - fprintf(proxy, "\n#ifndef _WIN64\n\n"); 1047 - pointer_size = 4; 1048 - write_proxy_routines( stmts ); 1049 - fprintf(proxy, "\n#else /* _WIN64 */\n\n"); 1050 - pointer_size = 8; 1051 - write_proxy_routines( stmts ); 1052 - fprintf(proxy, "\n#endif /* _WIN64 */\n"); 1053 - } 1054 - else if (do_win32) 1055 - { 1056 - pointer_size = 4; 1057 - write_proxy_routines( stmts ); 1058 - } 1059 - else if (do_win64) 1060 - { 1061 - pointer_size = 8; 1062 - write_proxy_routines( stmts ); 1063 - } 1064 - 1085 + write_proxy_routines( stmts ); 1065 1086 fclose(proxy); 1066 1087 }
+45 -2
sdk/tools/widl/register.c
··· 34 34 #include "parser.h" 35 35 #include "header.h" 36 36 #include "typegen.h" 37 + #ifndef __REACTOS__ 38 + #include "typelib.h" 39 + #endif 37 40 38 41 static int indent; 39 42 ··· 273 276 } 274 277 } 275 278 279 + #ifndef __REACTOS__ 280 + void write_typelib_regscript( const statement_list_t *stmts ) 281 + { 282 + const statement_t *stmt; 283 + unsigned int count = 0; 284 + 285 + if (!do_typelib) return; 286 + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) 287 + { 288 + if (stmt->type != STMT_LIBRARY) continue; 289 + if (count && !strendswith( typelib_name, ".res" )) 290 + error( "Cannot store multiple typelibs into %s\n", typelib_name ); 291 + else 292 + { 293 + if (do_old_typelib) 294 + create_sltg_typelib( stmt->u.lib ); 295 + else 296 + create_msft_typelib( stmt->u.lib ); 297 + } 298 + count++; 299 + } 300 + if (count && strendswith( typelib_name, ".res" )) flush_output_resources( typelib_name ); 301 + } 302 + #endif 303 + 276 304 void output_typelib_regscript( const typelib_t *typelib ) 277 305 { 278 306 const UUID *typelib_uuid = get_attrp( typelib->attrs, ATTR_UUID ); ··· 281 309 unsigned int version = get_attrv( typelib->attrs, ATTR_VERSION ); 282 310 unsigned int flags = 0; 283 311 char id_part[12] = ""; 312 + #ifndef __REACTOS__ 313 + char *resname = typelib_name; 314 + #endif 284 315 expr_t *expr; 285 316 286 317 if (is_attr( typelib->attrs, ATTR_RESTRICTED )) flags |= 1; /* LIBFLAG_FRESTRICTED */ ··· 298 329 MAJORVERSION(version), MINORVERSION(version), descr ? descr : typelib->name ); 299 330 put_str( indent++, "{\n" ); 300 331 expr = get_attrp( typelib->attrs, ATTR_ID ); 332 + #ifdef __REACTOS__ 301 333 if (expr) 302 334 sprintf(id_part, "\\%d", expr->cval); 335 + #else 336 + if (expr) 337 + { 338 + sprintf(id_part, "\\%d", expr->cval); 339 + resname = xmalloc( strlen(typelib_name) + 20 ); 340 + sprintf(resname, "%s\\%d", typelib_name, expr->cval); 341 + } 342 + #endif 303 343 put_str( indent, "'%x' { %s = s '%%MODULE%%%s' }\n", 304 - lcid_expr ? lcid_expr->cval : 0, typelib_kind == SYS_WIN64 ? "win64" : "win32", id_part ); 344 + lcid_expr ? lcid_expr->cval : 0, pointer_size == 8 ? "win64" : "win32", id_part ); 305 345 put_str( indent, "FLAGS = s '%u'\n", flags ); 306 346 put_str( --indent, "}\n" ); 307 347 put_str( --indent, "}\n" ); ··· 319 359 320 360 write_progids( typelib->stmts ); 321 361 put_str( --indent, "}\n" ); 322 - 362 + #ifdef __REACTOS__ 323 363 add_output_to_resources( "WINE_REGISTRY", typelib_name ); 364 + #else 365 + add_output_to_resources( "WINE_REGISTRY", resname ); 366 + #endif 324 367 }
+2 -22
sdk/tools/widl/server.c
··· 104 104 105 105 write_parameters_init(server, indent, func, "__frame->"); 106 106 107 - if (explicit_fc == RPC_FC_BIND_PRIMITIVE) 107 + if (explicit_fc == FC_BIND_PRIMITIVE) 108 108 { 109 109 print_server("__frame->%s = _pRpcMessage->Handle;\n", handle_var->name); 110 110 fprintf(server, "\n"); ··· 544 544 if (!server) 545 545 return; 546 546 547 - if (do_win32 && do_win64) 548 - { 549 - fprintf(server, "#ifndef _WIN64\n\n"); 550 - pointer_size = 4; 551 - write_server_routines( stmts ); 552 - fprintf(server, "\n#else /* _WIN64 */\n\n"); 553 - pointer_size = 8; 554 - write_server_routines( stmts ); 555 - fprintf(server, "\n#endif /* _WIN64 */\n"); 556 - } 557 - else if (do_win32) 558 - { 559 - pointer_size = 4; 560 - write_server_routines( stmts ); 561 - } 562 - else if (do_win64) 563 - { 564 - pointer_size = 8; 565 - write_server_routines( stmts ); 566 - } 567 - 547 + write_server_routines( stmts ); 568 548 fclose(server); 569 549 }
+523 -468
sdk/tools/widl/typegen.c
··· 84 84 85 85 static unsigned int field_memsize(const type_t *type, unsigned int *offset); 86 86 static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align); 87 - static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align); 88 87 static unsigned int write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type, 89 88 const char *name, unsigned int *typestring_offset); 90 89 static unsigned int write_struct_tfs(FILE *file, type_t *type, const char *name, unsigned int *tfsoff); ··· 103 102 { 104 103 switch (type) 105 104 { 106 - case RPC_FC_BYTE: return "FC_BYTE"; 107 - case RPC_FC_CHAR: return "FC_CHAR"; 108 - case RPC_FC_SMALL: return "FC_SMALL"; 109 - case RPC_FC_USMALL: return "FC_USMALL"; 110 - case RPC_FC_WCHAR: return "FC_WCHAR"; 111 - case RPC_FC_SHORT: return "FC_SHORT"; 112 - case RPC_FC_USHORT: return "FC_USHORT"; 113 - case RPC_FC_LONG: return "FC_LONG"; 114 - case RPC_FC_ULONG: return "FC_ULONG"; 115 - case RPC_FC_FLOAT: return "FC_FLOAT"; 116 - case RPC_FC_HYPER: return "FC_HYPER"; 117 - case RPC_FC_DOUBLE: return "FC_DOUBLE"; 118 - case RPC_FC_ENUM16: return "FC_ENUM16"; 119 - case RPC_FC_ENUM32: return "FC_ENUM32"; 120 - case RPC_FC_IGNORE: return "FC_IGNORE"; 121 - case RPC_FC_ERROR_STATUS_T: return "FC_ERROR_STATUS_T"; 122 - case RPC_FC_RP: return "FC_RP"; 123 - case RPC_FC_UP: return "FC_UP"; 124 - case RPC_FC_OP: return "FC_OP"; 125 - case RPC_FC_FP: return "FC_FP"; 126 - case RPC_FC_ENCAPSULATED_UNION: return "FC_ENCAPSULATED_UNION"; 127 - case RPC_FC_NON_ENCAPSULATED_UNION: return "FC_NON_ENCAPSULATED_UNION"; 128 - case RPC_FC_STRUCT: return "FC_STRUCT"; 129 - case RPC_FC_PSTRUCT: return "FC_PSTRUCT"; 130 - case RPC_FC_CSTRUCT: return "FC_CSTRUCT"; 131 - case RPC_FC_CPSTRUCT: return "FC_CPSTRUCT"; 132 - case RPC_FC_CVSTRUCT: return "FC_CVSTRUCT"; 133 - case RPC_FC_BOGUS_STRUCT: return "FC_BOGUS_STRUCT"; 134 - case RPC_FC_SMFARRAY: return "FC_SMFARRAY"; 135 - case RPC_FC_LGFARRAY: return "FC_LGFARRAY"; 136 - case RPC_FC_SMVARRAY: return "FC_SMVARRAY"; 137 - case RPC_FC_LGVARRAY: return "FC_LGVARRAY"; 138 - case RPC_FC_CARRAY: return "FC_CARRAY"; 139 - case RPC_FC_CVARRAY: return "FC_CVARRAY"; 140 - case RPC_FC_BOGUS_ARRAY: return "FC_BOGUS_ARRAY"; 141 - case RPC_FC_ALIGNM2: return "FC_ALIGNM2"; 142 - case RPC_FC_ALIGNM4: return "FC_ALIGNM4"; 143 - case RPC_FC_ALIGNM8: return "FC_ALIGNM8"; 144 - case RPC_FC_POINTER: return "FC_POINTER"; 145 - case RPC_FC_C_CSTRING: return "FC_C_CSTRING"; 146 - case RPC_FC_C_WSTRING: return "FC_C_WSTRING"; 147 - case RPC_FC_CSTRING: return "FC_CSTRING"; 148 - case RPC_FC_WSTRING: return "FC_WSTRING"; 149 - case RPC_FC_BYTE_COUNT_POINTER: return "FC_BYTE_COUNT_POINTER"; 150 - case RPC_FC_TRANSMIT_AS: return "FC_TRANSMIT_AS"; 151 - case RPC_FC_REPRESENT_AS: return "FC_REPRESENT_AS"; 152 - case RPC_FC_IP: return "FC_IP"; 153 - case RPC_FC_BIND_CONTEXT: return "FC_BIND_CONTEXT"; 154 - case RPC_FC_BIND_GENERIC: return "FC_BIND_GENERIC"; 155 - case RPC_FC_BIND_PRIMITIVE: return "FC_BIND_PRIMITIVE"; 156 - case RPC_FC_AUTO_HANDLE: return "FC_AUTO_HANDLE"; 157 - case RPC_FC_CALLBACK_HANDLE: return "FC_CALLBACK_HANDLE"; 158 - case RPC_FC_STRUCTPAD1: return "FC_STRUCTPAD1"; 159 - case RPC_FC_STRUCTPAD2: return "FC_STRUCTPAD2"; 160 - case RPC_FC_STRUCTPAD3: return "FC_STRUCTPAD3"; 161 - case RPC_FC_STRUCTPAD4: return "FC_STRUCTPAD4"; 162 - case RPC_FC_STRUCTPAD5: return "FC_STRUCTPAD5"; 163 - case RPC_FC_STRUCTPAD6: return "FC_STRUCTPAD6"; 164 - case RPC_FC_STRUCTPAD7: return "FC_STRUCTPAD7"; 165 - case RPC_FC_STRING_SIZED: return "FC_STRING_SIZED"; 166 - case RPC_FC_NO_REPEAT: return "FC_NO_REPEAT"; 167 - case RPC_FC_FIXED_REPEAT: return "FC_FIXED_REPEAT"; 168 - case RPC_FC_VARIABLE_REPEAT: return "FC_VARIABLE_REPEAT"; 169 - case RPC_FC_FIXED_OFFSET: return "FC_FIXED_OFFSET"; 170 - case RPC_FC_VARIABLE_OFFSET: return "FC_VARIABLE_OFFSET"; 171 - case RPC_FC_PP: return "FC_PP"; 172 - case RPC_FC_EMBEDDED_COMPLEX: return "FC_EMBEDDED_COMPLEX"; 173 - case RPC_FC_DEREFERENCE: return "FC_DEREFERENCE"; 174 - case RPC_FC_DIV_2: return "FC_DIV_2"; 175 - case RPC_FC_MULT_2: return "FC_MULT_2"; 176 - case RPC_FC_ADD_1: return "FC_ADD_1"; 177 - case RPC_FC_SUB_1: return "FC_SUB_1"; 178 - case RPC_FC_CALLBACK: return "FC_CALLBACK"; 179 - case RPC_FC_CONSTANT_IID: return "FC_CONSTANT_IID"; 180 - case RPC_FC_END: return "FC_END"; 181 - case RPC_FC_PAD: return "FC_PAD"; 182 - case RPC_FC_USER_MARSHAL: return "FC_USER_MARSHAL"; 183 - case RPC_FC_RANGE: return "FC_RANGE"; 184 - case RPC_FC_INT3264: return "FC_INT3264"; 185 - case RPC_FC_UINT3264: return "FC_UINT3264"; 105 + case FC_BYTE: return "FC_BYTE"; 106 + case FC_CHAR: return "FC_CHAR"; 107 + case FC_SMALL: return "FC_SMALL"; 108 + case FC_USMALL: return "FC_USMALL"; 109 + case FC_WCHAR: return "FC_WCHAR"; 110 + case FC_SHORT: return "FC_SHORT"; 111 + case FC_USHORT: return "FC_USHORT"; 112 + case FC_LONG: return "FC_LONG"; 113 + case FC_ULONG: return "FC_ULONG"; 114 + case FC_FLOAT: return "FC_FLOAT"; 115 + case FC_HYPER: return "FC_HYPER"; 116 + case FC_DOUBLE: return "FC_DOUBLE"; 117 + case FC_ENUM16: return "FC_ENUM16"; 118 + case FC_ENUM32: return "FC_ENUM32"; 119 + case FC_IGNORE: return "FC_IGNORE"; 120 + case FC_ERROR_STATUS_T: return "FC_ERROR_STATUS_T"; 121 + case FC_RP: return "FC_RP"; 122 + case FC_UP: return "FC_UP"; 123 + case FC_OP: return "FC_OP"; 124 + case FC_FP: return "FC_FP"; 125 + case FC_ENCAPSULATED_UNION: return "FC_ENCAPSULATED_UNION"; 126 + case FC_NON_ENCAPSULATED_UNION: return "FC_NON_ENCAPSULATED_UNION"; 127 + case FC_STRUCT: return "FC_STRUCT"; 128 + case FC_PSTRUCT: return "FC_PSTRUCT"; 129 + case FC_CSTRUCT: return "FC_CSTRUCT"; 130 + case FC_CPSTRUCT: return "FC_CPSTRUCT"; 131 + case FC_CVSTRUCT: return "FC_CVSTRUCT"; 132 + case FC_BOGUS_STRUCT: return "FC_BOGUS_STRUCT"; 133 + case FC_SMFARRAY: return "FC_SMFARRAY"; 134 + case FC_LGFARRAY: return "FC_LGFARRAY"; 135 + case FC_SMVARRAY: return "FC_SMVARRAY"; 136 + case FC_LGVARRAY: return "FC_LGVARRAY"; 137 + case FC_CARRAY: return "FC_CARRAY"; 138 + case FC_CVARRAY: return "FC_CVARRAY"; 139 + case FC_BOGUS_ARRAY: return "FC_BOGUS_ARRAY"; 140 + case FC_ALIGNM2: return "FC_ALIGNM2"; 141 + case FC_ALIGNM4: return "FC_ALIGNM4"; 142 + case FC_ALIGNM8: return "FC_ALIGNM8"; 143 + case FC_POINTER: return "FC_POINTER"; 144 + case FC_C_CSTRING: return "FC_C_CSTRING"; 145 + case FC_C_WSTRING: return "FC_C_WSTRING"; 146 + case FC_CSTRING: return "FC_CSTRING"; 147 + case FC_WSTRING: return "FC_WSTRING"; 148 + case FC_BYTE_COUNT_POINTER: return "FC_BYTE_COUNT_POINTER"; 149 + case FC_TRANSMIT_AS: return "FC_TRANSMIT_AS"; 150 + case FC_REPRESENT_AS: return "FC_REPRESENT_AS"; 151 + case FC_IP: return "FC_IP"; 152 + case FC_BIND_CONTEXT: return "FC_BIND_CONTEXT"; 153 + case FC_BIND_GENERIC: return "FC_BIND_GENERIC"; 154 + case FC_BIND_PRIMITIVE: return "FC_BIND_PRIMITIVE"; 155 + case FC_AUTO_HANDLE: return "FC_AUTO_HANDLE"; 156 + case FC_CALLBACK_HANDLE: return "FC_CALLBACK_HANDLE"; 157 + case FC_STRUCTPAD1: return "FC_STRUCTPAD1"; 158 + case FC_STRUCTPAD2: return "FC_STRUCTPAD2"; 159 + case FC_STRUCTPAD3: return "FC_STRUCTPAD3"; 160 + case FC_STRUCTPAD4: return "FC_STRUCTPAD4"; 161 + case FC_STRUCTPAD5: return "FC_STRUCTPAD5"; 162 + case FC_STRUCTPAD6: return "FC_STRUCTPAD6"; 163 + case FC_STRUCTPAD7: return "FC_STRUCTPAD7"; 164 + case FC_STRING_SIZED: return "FC_STRING_SIZED"; 165 + case FC_NO_REPEAT: return "FC_NO_REPEAT"; 166 + case FC_FIXED_REPEAT: return "FC_FIXED_REPEAT"; 167 + case FC_VARIABLE_REPEAT: return "FC_VARIABLE_REPEAT"; 168 + case FC_FIXED_OFFSET: return "FC_FIXED_OFFSET"; 169 + case FC_VARIABLE_OFFSET: return "FC_VARIABLE_OFFSET"; 170 + case FC_PP: return "FC_PP"; 171 + case FC_EMBEDDED_COMPLEX: return "FC_EMBEDDED_COMPLEX"; 172 + case FC_DEREFERENCE: return "FC_DEREFERENCE"; 173 + case FC_DIV_2: return "FC_DIV_2"; 174 + case FC_MULT_2: return "FC_MULT_2"; 175 + case FC_ADD_1: return "FC_ADD_1"; 176 + case FC_SUB_1: return "FC_SUB_1"; 177 + case FC_CALLBACK: return "FC_CALLBACK"; 178 + case FC_CONSTANT_IID: return "FC_CONSTANT_IID"; 179 + case FC_END: return "FC_END"; 180 + case FC_PAD: return "FC_PAD"; 181 + case FC_USER_MARSHAL: return "FC_USER_MARSHAL"; 182 + case FC_RANGE: return "FC_RANGE"; 183 + case FC_INT3264: return "FC_INT3264"; 184 + case FC_UINT3264: return "FC_UINT3264"; 186 185 default: 187 186 error("string_of_type: unknown type 0x%02x\n", type); 188 187 return NULL; ··· 207 206 int sign = type_basic_get_sign(type); 208 207 switch (type_basic_get_type(type)) 209 208 { 210 - case TYPE_BASIC_INT8: return (sign <= 0 ? RPC_FC_SMALL : RPC_FC_USMALL); 211 - case TYPE_BASIC_INT16: return (sign <= 0 ? RPC_FC_SHORT : RPC_FC_USHORT); 212 - case TYPE_BASIC_INT32: return (sign <= 0 ? RPC_FC_LONG : RPC_FC_ULONG); 213 - case TYPE_BASIC_INT64: return RPC_FC_HYPER; 214 - case TYPE_BASIC_INT: return (sign <= 0 ? RPC_FC_LONG : RPC_FC_ULONG); 215 - case TYPE_BASIC_INT3264: return (sign <= 0 ? RPC_FC_INT3264 : RPC_FC_UINT3264); 216 - case TYPE_BASIC_BYTE: return RPC_FC_BYTE; 217 - case TYPE_BASIC_CHAR: return RPC_FC_CHAR; 218 - case TYPE_BASIC_WCHAR: return RPC_FC_WCHAR; 219 - case TYPE_BASIC_HYPER: return RPC_FC_HYPER; 220 - case TYPE_BASIC_FLOAT: return RPC_FC_FLOAT; 221 - case TYPE_BASIC_DOUBLE: return RPC_FC_DOUBLE; 222 - case TYPE_BASIC_ERROR_STATUS_T: return RPC_FC_ERROR_STATUS_T; 223 - case TYPE_BASIC_HANDLE: return RPC_FC_BIND_PRIMITIVE; 209 + case TYPE_BASIC_INT8: return (sign <= 0 ? FC_SMALL : FC_USMALL); 210 + case TYPE_BASIC_INT16: return (sign <= 0 ? FC_SHORT : FC_USHORT); 211 + case TYPE_BASIC_INT32: 212 + case TYPE_BASIC_LONG: return (sign <= 0 ? FC_LONG : FC_ULONG); 213 + case TYPE_BASIC_INT64: return FC_HYPER; 214 + case TYPE_BASIC_INT: return (sign <= 0 ? FC_LONG : FC_ULONG); 215 + case TYPE_BASIC_INT3264: return (sign <= 0 ? FC_INT3264 : FC_UINT3264); 216 + case TYPE_BASIC_BYTE: return FC_BYTE; 217 + case TYPE_BASIC_CHAR: return FC_CHAR; 218 + case TYPE_BASIC_WCHAR: return FC_WCHAR; 219 + case TYPE_BASIC_HYPER: return FC_HYPER; 220 + case TYPE_BASIC_FLOAT: return FC_FLOAT; 221 + case TYPE_BASIC_DOUBLE: return FC_DOUBLE; 222 + case TYPE_BASIC_ERROR_STATUS_T: return FC_ERROR_STATUS_T; 223 + case TYPE_BASIC_HANDLE: return FC_BIND_PRIMITIVE; 224 224 } 225 225 return 0; 226 226 } ··· 229 229 { 230 230 switch (type_basic_get_type(type)) 231 231 { 232 - case TYPE_BASIC_INT8: return RPC_FC_SMALL; 233 - case TYPE_BASIC_INT16: return RPC_FC_SHORT; 234 - case TYPE_BASIC_INT32: return RPC_FC_LONG; 235 - case TYPE_BASIC_INT64: return RPC_FC_HYPER; 236 - case TYPE_BASIC_INT: return RPC_FC_LONG; 237 - case TYPE_BASIC_INT3264: return RPC_FC_INT3264; 238 - case TYPE_BASIC_BYTE: return RPC_FC_BYTE; 239 - case TYPE_BASIC_CHAR: return RPC_FC_CHAR; 240 - case TYPE_BASIC_WCHAR: return RPC_FC_WCHAR; 241 - case TYPE_BASIC_HYPER: return RPC_FC_HYPER; 242 - case TYPE_BASIC_FLOAT: return RPC_FC_FLOAT; 243 - case TYPE_BASIC_DOUBLE: return RPC_FC_DOUBLE; 244 - case TYPE_BASIC_ERROR_STATUS_T: return RPC_FC_ERROR_STATUS_T; 245 - case TYPE_BASIC_HANDLE: return RPC_FC_BIND_PRIMITIVE; 232 + case TYPE_BASIC_INT8: return FC_SMALL; 233 + case TYPE_BASIC_INT16: return FC_SHORT; 234 + case TYPE_BASIC_INT32: return FC_LONG; 235 + case TYPE_BASIC_INT64: return FC_HYPER; 236 + case TYPE_BASIC_INT: return FC_LONG; 237 + case TYPE_BASIC_INT3264: return FC_INT3264; 238 + case TYPE_BASIC_LONG: return FC_LONG; 239 + case TYPE_BASIC_BYTE: return FC_BYTE; 240 + case TYPE_BASIC_CHAR: return FC_CHAR; 241 + case TYPE_BASIC_WCHAR: return FC_WCHAR; 242 + case TYPE_BASIC_HYPER: return FC_HYPER; 243 + case TYPE_BASIC_FLOAT: return FC_FLOAT; 244 + case TYPE_BASIC_DOUBLE: return FC_DOUBLE; 245 + case TYPE_BASIC_ERROR_STATUS_T: return FC_ERROR_STATUS_T; 246 + case TYPE_BASIC_HANDLE: return FC_BIND_PRIMITIVE; 246 247 } 247 248 return 0; 248 249 } ··· 273 274 } 274 275 275 276 if (toplevel_param) 276 - return RPC_FC_RP; 277 + return FC_RP; 277 278 else if (is_ptr(type)) 278 279 return type_pointer_get_default_fc(type); 279 280 else ··· 285 286 { 286 287 int pointer_fc = get_pointer_fc(type, attrs, context == TYPE_CONTEXT_TOPLEVELPARAM); 287 288 288 - if (pointer_fc == RPC_FC_UP && is_attr( attrs, ATTR_OUT ) && 289 + if (pointer_fc == FC_UP && is_attr( attrs, ATTR_OUT ) && 289 290 context == TYPE_CONTEXT_PARAM && is_object( current_iface )) 290 - pointer_fc = RPC_FC_OP; 291 + pointer_fc = FC_OP; 291 292 292 293 return pointer_fc; 293 294 } ··· 296 297 { 297 298 assert(type_get_type(type) == TYPE_ENUM); 298 299 if (is_aliaschain_attr(type, ATTR_V1ENUM)) 299 - return RPC_FC_ENUM32; 300 + return FC_ENUM32; 300 301 else 301 - return RPC_FC_ENUM16; 302 + return FC_ENUM16; 302 303 } 303 304 304 305 static type_t *get_user_type(const type_t *t, const char **pname) ··· 383 384 if (!type_array_is_decl_as_ptr( v->type )) return 0; 384 385 /* fall through */ 385 386 case TGT_POINTER: 386 - return (get_pointer_fc(v->type, v->attrs, TRUE) == RPC_FC_RP); 387 + return (get_pointer_fc(v->type, v->attrs, TRUE) == FC_RP); 387 388 case TGT_CTXT_HANDLE_POINTER: 388 389 return TRUE; 389 390 default: ··· 485 486 fields = type_struct_get_fields(type); 486 487 487 488 if (get_padding(fields)) 488 - return RPC_FC_BOGUS_STRUCT; 489 + return FC_BOGUS_STRUCT; 489 490 490 491 if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry ) 491 492 { ··· 505 506 } 506 507 507 508 if (is_array(type_array_get_element(field->type))) 508 - return RPC_FC_BOGUS_STRUCT; 509 + return FC_BOGUS_STRUCT; 509 510 510 511 if (type_array_has_conformance(field->type)) 511 512 { ··· 525 526 { 526 527 case TGT_USER_TYPE: 527 528 case TGT_IFACE_POINTER: 528 - return RPC_FC_BOGUS_STRUCT; 529 + return FC_BOGUS_STRUCT; 529 530 case TGT_BASIC: 530 531 if (type_basic_get_type(t) == TYPE_BASIC_INT3264 && pointer_size != 4) 531 - return RPC_FC_BOGUS_STRUCT; 532 + return FC_BOGUS_STRUCT; 532 533 break; 533 534 case TGT_ENUM: 534 - if (get_enum_fc(t) == RPC_FC_ENUM16) 535 - return RPC_FC_BOGUS_STRUCT; 535 + if (get_enum_fc(t) == FC_ENUM16) 536 + return FC_BOGUS_STRUCT; 536 537 break; 537 538 case TGT_POINTER: 538 539 case TGT_ARRAY: 539 - if (get_pointer_fc(t, field->attrs, FALSE) == RPC_FC_RP || pointer_size != 4) 540 - return RPC_FC_BOGUS_STRUCT; 540 + if (get_pointer_fc(t, field->attrs, FALSE) == FC_RP || pointer_size != 4) 541 + return FC_BOGUS_STRUCT; 541 542 has_pointer = 1; 542 543 break; 543 544 case TGT_UNION: 544 - return RPC_FC_BOGUS_STRUCT; 545 + return FC_BOGUS_STRUCT; 545 546 case TGT_STRUCT: 546 547 { 547 548 unsigned char fc = get_struct_fc(t); 548 549 switch (fc) 549 550 { 550 - case RPC_FC_STRUCT: 551 + case FC_STRUCT: 551 552 break; 552 - case RPC_FC_CVSTRUCT: 553 + case FC_CVSTRUCT: 553 554 has_conformance = 1; 554 555 has_variance = 1; 555 556 has_pointer = 1; 556 557 break; 557 558 558 - case RPC_FC_CPSTRUCT: 559 + case FC_CPSTRUCT: 559 560 has_conformance = 1; 560 561 if (list_next( fields, &field->entry )) 561 562 error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n", ··· 563 564 has_pointer = 1; 564 565 break; 565 566 566 - case RPC_FC_CSTRUCT: 567 + case FC_CSTRUCT: 567 568 has_conformance = 1; 568 569 if (list_next( fields, &field->entry )) 569 570 error_loc("field '%s' deriving from a conformant array must be the last field in the structure\n", 570 571 field->name); 571 572 break; 572 573 573 - case RPC_FC_PSTRUCT: 574 + case FC_PSTRUCT: 574 575 has_pointer = 1; 575 576 break; 576 577 ··· 579 580 /* fallthru - treat it as complex */ 580 581 581 582 /* as soon as we see one of these these members, it's bogus... */ 582 - case RPC_FC_BOGUS_STRUCT: 583 - return RPC_FC_BOGUS_STRUCT; 583 + case FC_BOGUS_STRUCT: 584 + return FC_BOGUS_STRUCT; 584 585 } 585 586 break; 586 587 } 587 588 case TGT_RANGE: 588 - return RPC_FC_BOGUS_STRUCT; 589 + return FC_BOGUS_STRUCT; 589 590 case TGT_STRING: 590 591 /* shouldn't get here because of TDT_IGNORE_STRINGS above. fall through */ 591 592 case TGT_INVALID: ··· 600 601 if( has_variance ) 601 602 { 602 603 if ( has_conformance ) 603 - return RPC_FC_CVSTRUCT; 604 + return FC_CVSTRUCT; 604 605 else 605 - return RPC_FC_BOGUS_STRUCT; 606 + return FC_BOGUS_STRUCT; 606 607 } 607 608 if( has_conformance && has_pointer ) 608 - return RPC_FC_CPSTRUCT; 609 + return FC_CPSTRUCT; 609 610 if( has_conformance ) 610 - return RPC_FC_CSTRUCT; 611 + return FC_CSTRUCT; 611 612 if( has_pointer ) 612 - return RPC_FC_PSTRUCT; 613 - return RPC_FC_STRUCT; 613 + return FC_PSTRUCT; 614 + return FC_STRUCT; 614 615 } 615 616 616 617 static unsigned char get_array_fc(const type_t *type) ··· 626 627 { 627 628 unsigned int size = type_memsize(elem_type); 628 629 if (size * type_array_get_dim(type) > 0xffffuL) 629 - fc = RPC_FC_LGFARRAY; 630 + fc = FC_LGFARRAY; 630 631 else 631 - fc = RPC_FC_SMFARRAY; 632 + fc = FC_SMFARRAY; 632 633 } 633 634 else 634 - fc = RPC_FC_CARRAY; 635 + fc = FC_CARRAY; 635 636 636 637 if (type_array_has_variance(type)) 637 638 { 638 - if (fc == RPC_FC_SMFARRAY) 639 - fc = RPC_FC_SMVARRAY; 640 - else if (fc == RPC_FC_LGFARRAY) 641 - fc = RPC_FC_LGVARRAY; 642 - else if (fc == RPC_FC_CARRAY) 643 - fc = RPC_FC_CVARRAY; 639 + if (fc == FC_SMFARRAY) 640 + fc = FC_SMVARRAY; 641 + else if (fc == FC_LGFARRAY) 642 + fc = FC_LGVARRAY; 643 + else if (fc == FC_CARRAY) 644 + fc = FC_CVARRAY; 644 645 } 645 646 646 647 switch (typegen_detect_type(elem_type, NULL, TDT_IGNORE_STRINGS)) 647 648 { 648 649 case TGT_USER_TYPE: 649 - fc = RPC_FC_BOGUS_ARRAY; 650 + fc = FC_BOGUS_ARRAY; 650 651 break; 651 652 case TGT_BASIC: 652 653 if (type_basic_get_type(elem_type) == TYPE_BASIC_INT3264 && 653 654 pointer_size != 4) 654 - fc = RPC_FC_BOGUS_ARRAY; 655 + fc = FC_BOGUS_ARRAY; 655 656 break; 656 657 case TGT_STRUCT: 657 658 switch (get_struct_fc(elem_type)) 658 659 { 659 - case RPC_FC_BOGUS_STRUCT: 660 - fc = RPC_FC_BOGUS_ARRAY; 660 + case FC_BOGUS_STRUCT: 661 + fc = FC_BOGUS_ARRAY; 661 662 break; 662 663 } 663 664 break; 664 665 case TGT_ENUM: 665 666 /* is 16-bit enum - if so, wire size differs from mem size and so 666 667 * the array cannot be block copied, which means the array is complex */ 667 - if (get_enum_fc(elem_type) == RPC_FC_ENUM16) 668 - fc = RPC_FC_BOGUS_ARRAY; 668 + if (get_enum_fc(elem_type) == FC_ENUM16) 669 + fc = FC_BOGUS_ARRAY; 669 670 break; 670 671 case TGT_UNION: 671 672 case TGT_IFACE_POINTER: 672 - fc = RPC_FC_BOGUS_ARRAY; 673 + fc = FC_BOGUS_ARRAY; 673 674 break; 674 675 case TGT_POINTER: 675 676 /* ref pointers cannot just be block copied. unique pointers to 676 677 * interfaces need special treatment. either case means the array is 677 678 * complex */ 678 - if (get_pointer_fc(elem_type, NULL, FALSE) == RPC_FC_RP || pointer_size != 4) 679 - fc = RPC_FC_BOGUS_ARRAY; 679 + if (get_pointer_fc(elem_type, NULL, FALSE) == FC_RP || pointer_size != 4) 680 + fc = FC_BOGUS_ARRAY; 680 681 break; 681 682 case TGT_RANGE: 682 - fc = RPC_FC_BOGUS_ARRAY; 683 + fc = FC_BOGUS_ARRAY; 683 684 break; 684 685 case TGT_CTXT_HANDLE: 685 686 case TGT_CTXT_HANDLE_POINTER: ··· 696 697 static int is_non_complex_struct(const type_t *type) 697 698 { 698 699 return (type_get_type(type) == TYPE_STRUCT && 699 - get_struct_fc(type) != RPC_FC_BOGUS_STRUCT); 700 + get_struct_fc(type) != FC_BOGUS_STRUCT); 700 701 } 701 702 702 703 static int type_has_pointers(const type_t *type) ··· 754 755 case TGT_USER_TYPE: 755 756 return FALSE; 756 757 case TGT_POINTER: 757 - if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_FP) 758 + if (get_pointer_fc(type, attrs, toplevel_param) == FC_FP) 758 759 return TRUE; 759 760 else 760 761 return FALSE; 761 762 case TGT_ARRAY: 762 - if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_FP) 763 + if (get_pointer_fc(type, attrs, toplevel_param) == FC_FP) 763 764 return TRUE; 764 765 else 765 766 return type_has_full_pointer(type_array_get_element(type), NULL, FALSE); ··· 862 863 do { \ 863 864 if (file) \ 864 865 fprintf(file, "/* %2u */\n", typestring_offset); \ 865 - print_file((file), 2, "0x%02x,\t/* " #fctype " */\n", RPC_##fctype); \ 866 + print_file((file), 2, "0x%02x,\t/* " #fctype " */\n", fctype); \ 866 867 } \ 867 868 while (0) 868 869 ··· 982 983 case TGT_BASIC: 983 984 *flags |= IsBasetype; 984 985 fc = get_basic_fc_signed( var->type ); 985 - if (fc == RPC_FC_BIND_PRIMITIVE) 986 + if (fc == FC_BIND_PRIMITIVE) 986 987 { 987 988 buffer_size = 4; /* actually 0 but avoids setting MustSize */ 988 - fc = RPC_FC_LONG; 989 + fc = FC_LONG; 989 990 } 990 991 break; 991 992 case TGT_ENUM: ··· 1006 1007 case TGT_ARRAY: 1007 1008 *flags |= MustFree; 1008 1009 if (type_array_is_decl_as_ptr(var->type) && var->type->details.array.ptr_tfsoff && 1009 - get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) 1010 + get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) 1010 1011 { 1011 1012 *typestring_offset = var->type->typestring_offset; 1012 1013 *flags |= IsSimpleRef; ··· 1014 1015 break; 1015 1016 case TGT_STRING: 1016 1017 *flags |= MustFree; 1017 - if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) 1018 + if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) 1018 1019 { 1019 1020 /* skip over pointer description straight to string description */ 1020 1021 if (is_conformant_array( var->type )) *typestring_offset += 4; ··· 1030 1031 buffer_size = 20; 1031 1032 break; 1032 1033 case TGT_POINTER: 1033 - if (get_pointer_fc( var->type, var->attrs, !is_return ) == RPC_FC_RP) 1034 + if (get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) 1034 1035 { 1035 1036 const type_t *ref = type_pointer_get_ref( var->type ); 1036 1037 ··· 1045 1046 if (!is_in && is_out) server_size = pointer_size; 1046 1047 break; 1047 1048 case TGT_ENUM: 1048 - if ((fc = get_enum_fc( ref )) == RPC_FC_ENUM32) 1049 + if ((fc = get_enum_fc( ref )) == FC_ENUM32) 1049 1050 { 1050 1051 *flags |= IsSimpleRef | IsBasetype; 1051 1052 if (!is_in && is_out) server_size = pointer_size; ··· 1058 1059 case TGT_UNION: 1059 1060 case TGT_USER_TYPE: 1060 1061 case TGT_RANGE: 1062 + case TGT_ARRAY: 1061 1063 *flags |= IsSimpleRef | MustFree; 1062 1064 *typestring_offset = ref->typestring_offset; 1063 1065 if (!is_in && is_out) server_size = type_memsize( ref ); 1064 1066 break; 1065 1067 case TGT_STRING: 1066 1068 case TGT_POINTER: 1067 - case TGT_ARRAY: 1068 1069 case TGT_CTXT_HANDLE: 1069 1070 case TGT_CTXT_HANDLE_POINTER: 1070 1071 *flags |= MustFree; ··· 1079 1080 *typestring_offset = ref->typestring_offset; 1080 1081 switch (get_struct_fc(ref)) 1081 1082 { 1082 - case RPC_FC_STRUCT: 1083 - case RPC_FC_PSTRUCT: 1084 - case RPC_FC_BOGUS_STRUCT: 1083 + case FC_STRUCT: 1084 + case FC_PSTRUCT: 1085 + case FC_BOGUS_STRUCT: 1085 1086 if (!is_in && is_out) server_size = type_memsize( ref ); 1086 1087 break; 1087 1088 default: ··· 1202 1203 { 1203 1204 fc = get_basic_fc_signed(var->type); 1204 1205 1205 - if (fc == RPC_FC_BIND_PRIMITIVE) 1206 - fc = RPC_FC_IGNORE; 1206 + if (fc == FC_BIND_PRIMITIVE) 1207 + fc = FC_IGNORE; 1207 1208 } 1208 1209 1209 1210 print_file(file, indent, "0x%02x, /* %s */\n", ··· 1295 1296 unsigned char explicit_fc, implicit_fc; 1296 1297 unsigned char handle_flags; 1297 1298 const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); 1298 - unsigned char oi_flags = RPC_FC_PROC_OIF_RPCFLAGS | RPC_FC_PROC_OIF_NEWINIT; 1299 + unsigned char oi_flags = Oi_HAS_RPCFLAGS | Oi_USE_NEW_INIT_ROUTINES; 1299 1300 unsigned int rpc_flags = get_rpc_flags( func->attrs ); 1300 1301 unsigned int nb_args = 0; 1301 1302 unsigned int stack_size = 0; ··· 1303 1304 unsigned short handle_stack_offset = 0; 1304 1305 unsigned short handle_param_num = 0; 1305 1306 1306 - if (is_full_pointer_function( func )) oi_flags |= RPC_FC_PROC_OIF_FULLPTR; 1307 + if (is_full_pointer_function( func )) oi_flags |= Oi_FULL_PTR_USED; 1307 1308 if (is_object( iface )) 1308 1309 { 1309 - oi_flags |= RPC_FC_PROC_OIF_OBJECT; 1310 - if (get_stub_mode() == MODE_Oif) oi_flags |= RPC_FC_PROC_OIF_OBJ_V2; 1310 + oi_flags |= Oi_OBJECT_PROC; 1311 + if (get_stub_mode() == MODE_Oif) oi_flags |= Oi_OBJ_USE_V2_INTERPRETER; 1311 1312 stack_size += pointer_size; 1312 1313 } 1313 1314 ··· 1341 1342 { 1342 1343 switch (explicit_fc) 1343 1344 { 1344 - case RPC_FC_BIND_PRIMITIVE: 1345 + case FC_BIND_PRIMITIVE: 1345 1346 handle_flags = 0; 1346 1347 print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); 1347 1348 print_file( file, indent, "0x%02x,\n", handle_flags ); ··· 1349 1350 handle_stack_offset, handle_stack_offset ); 1350 1351 *offset += 4; 1351 1352 break; 1352 - case RPC_FC_BIND_GENERIC: 1353 + case FC_BIND_GENERIC: 1353 1354 handle_flags = type_memsize( handle_var->type ); 1354 1355 print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); 1355 1356 print_file( file, indent, "0x%02x,\n", handle_flags ); 1356 1357 print_file( file, indent, "NdrFcShort(0x%hx),\t/* stack offset = %hu */\n", 1357 1358 handle_stack_offset, handle_stack_offset ); 1358 1359 print_file( file, indent, "0x%02x,\n", get_generic_handle_offset( handle_var->type ) ); 1359 - print_file( file, indent, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); 1360 + print_file( file, indent, "0x%x,\t/* FC_PAD */\n", FC_PAD); 1360 1361 *offset += 6; 1361 1362 break; 1362 - case RPC_FC_BIND_CONTEXT: 1363 + case FC_BIND_CONTEXT: 1363 1364 handle_flags = get_contexthandle_flags( iface, handle_var->attrs, handle_var->type ); 1364 1365 print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); 1365 1366 print_file( file, indent, "0x%02x,\n", handle_flags ); ··· 1380 1381 1381 1382 if (is_attr( func->attrs, ATTR_NOTIFY )) ext_flags |= 0x08; /* HasNotify */ 1382 1383 if (is_attr( func->attrs, ATTR_NOTIFYFLAG )) ext_flags |= 0x10; /* HasNotify2 */ 1384 + if (iface == iface->details.iface->async_iface) oi2_flags |= 0x20; 1383 1385 1384 1386 size = get_function_buffer_size( func, PASS_IN ); 1385 1387 print_file( file, indent, "NdrFcShort(0x%x),\t/* client buffer = %u */\n", size, size ); ··· 1464 1466 } 1465 1467 } 1466 1468 1467 - static void write_procformatstring_stmts(FILE *file, int indent, const statement_list_t *stmts, 1468 - type_pred_t pred, unsigned int *offset) 1469 + static void for_each_iface(const statement_list_t *stmts, 1470 + void (*proc)(type_t *iface, FILE *file, int indent, unsigned int *offset), 1471 + type_pred_t pred, FILE *file, int indent, unsigned int *offset) 1469 1472 { 1470 1473 const statement_t *stmt; 1474 + type_t *iface; 1475 + 1471 1476 if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) 1472 1477 { 1473 - if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE) 1474 - { 1475 - const statement_t *stmt_func; 1476 - const type_t *iface = stmt->u.type; 1477 - const type_t *parent = type_iface_get_inherit( iface ); 1478 - int count = parent ? count_methods( parent ) : 0; 1478 + if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) 1479 + continue; 1480 + iface = stmt->u.type; 1481 + if (!pred(iface)) continue; 1482 + proc(iface, file, indent, offset); 1483 + if (iface->details.iface->async_iface) 1484 + proc(iface->details.iface->async_iface, file, indent, offset); 1485 + } 1486 + } 1487 + 1488 + static void write_iface_procformatstring(type_t *iface, FILE *file, int indent, unsigned int *offset) 1489 + { 1490 + const statement_t *stmt; 1491 + const type_t *parent = type_iface_get_inherit( iface ); 1492 + int count = parent ? count_methods( parent ) : 0; 1479 1493 1480 - if (!pred(iface)) continue; 1481 - STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(iface)) 1482 - { 1483 - var_t *func = stmt_func->u.var; 1484 - if (is_local(func->attrs)) continue; 1485 - write_procformatstring_func( file, indent, iface, func, offset, count++ ); 1486 - } 1487 - } 1494 + STATEMENTS_FOR_EACH_FUNC(stmt, type_iface_get_stmts(iface)) 1495 + { 1496 + var_t *func = stmt->u.var; 1497 + if (is_local(func->attrs)) continue; 1498 + write_procformatstring_func( file, indent, iface, func, offset, count++ ); 1488 1499 } 1489 1500 } 1490 1501 ··· 1500 1511 print_file(file, indent, "{\n"); 1501 1512 indent++; 1502 1513 1503 - write_procformatstring_stmts(file, indent, stmts, pred, &offset); 1514 + for_each_iface(stmts, write_iface_procformatstring, pred, file, indent, &offset); 1504 1515 1505 1516 print_file(file, indent, "0x0\n"); 1506 1517 indent--; ··· 1551 1562 const expr_t *expr) 1552 1563 { 1553 1564 unsigned char operator_type = 0; 1554 - unsigned char conftype = RPC_FC_NORMAL_CONFORMANCE; 1565 + unsigned char conftype = FC_NORMAL_CONFORMANCE; 1555 1566 const char *conftype_string = "field"; 1556 1567 const expr_t *subexpr; 1557 1568 const type_t *iface = NULL; ··· 1571 1582 UCHAR_MAX * (USHRT_MAX + 1) + USHRT_MAX); 1572 1583 1573 1584 print_file(file, 2, "0x%x, /* Corr desc: constant, val = %d */\n", 1574 - RPC_FC_CONSTANT_CONFORMANCE, expr->cval); 1585 + FC_CONSTANT_CONFORMANCE, expr->cval); 1575 1586 print_file(file, 2, "0x%x,\n", expr->cval >> 16); 1576 1587 print_file(file, 2, "NdrFcShort(0x%hx),\n", (unsigned short)expr->cval); 1577 1588 ··· 1580 1591 1581 1592 if (!cont_type) /* top-level conformance */ 1582 1593 { 1583 - conftype = RPC_FC_TOP_LEVEL_CONFORMANCE; 1594 + conftype = FC_TOP_LEVEL_CONFORMANCE; 1584 1595 conftype_string = "parameter"; 1585 1596 cont_type = current_func->type; 1586 1597 name = current_func->name; ··· 1591 1602 name = cont_type->name; 1592 1603 if (is_ptr(type) || (is_array(type) && type_array_is_decl_as_ptr(type))) 1593 1604 { 1594 - conftype = RPC_FC_POINTER_CONFORMANCE; 1605 + conftype = FC_POINTER_CONFORMANCE; 1595 1606 conftype_string = "field pointer"; 1596 1607 } 1597 1608 } ··· 1601 1612 { 1602 1613 case EXPR_PPTR: 1603 1614 subexpr = subexpr->ref; 1604 - operator_type = RPC_FC_DEREFERENCE; 1615 + operator_type = FC_DEREFERENCE; 1605 1616 break; 1606 1617 case EXPR_DIV: 1607 1618 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2)) 1608 1619 { 1609 1620 subexpr = subexpr->ref; 1610 - operator_type = RPC_FC_DIV_2; 1621 + operator_type = FC_DIV_2; 1611 1622 } 1612 1623 break; 1613 1624 case EXPR_MUL: 1614 1625 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 2)) 1615 1626 { 1616 1627 subexpr = subexpr->ref; 1617 - operator_type = RPC_FC_MULT_2; 1628 + operator_type = FC_MULT_2; 1618 1629 } 1619 1630 break; 1620 1631 case EXPR_SUB: 1621 1632 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1)) 1622 1633 { 1623 1634 subexpr = subexpr->ref; 1624 - operator_type = RPC_FC_SUB_1; 1635 + operator_type = FC_SUB_1; 1625 1636 } 1626 1637 break; 1627 1638 case EXPR_ADD: 1628 1639 if (subexpr->u.ext->is_const && (subexpr->u.ext->cval == 1)) 1629 1640 { 1630 1641 subexpr = subexpr->ref; 1631 - operator_type = RPC_FC_ADD_1; 1642 + operator_type = FC_ADD_1; 1632 1643 } 1633 1644 break; 1634 1645 default: ··· 1687 1698 { 1688 1699 switch (get_basic_fc(correlation_variable)) 1689 1700 { 1690 - case RPC_FC_CHAR: 1691 - case RPC_FC_SMALL: 1692 - param_type = RPC_FC_SMALL; 1701 + case FC_CHAR: 1702 + case FC_SMALL: 1703 + param_type = FC_SMALL; 1693 1704 break; 1694 - case RPC_FC_BYTE: 1695 - case RPC_FC_USMALL: 1696 - param_type = RPC_FC_USMALL; 1705 + case FC_BYTE: 1706 + case FC_USMALL: 1707 + param_type = FC_USMALL; 1697 1708 break; 1698 - case RPC_FC_WCHAR: 1699 - case RPC_FC_SHORT: 1700 - param_type = RPC_FC_SHORT; 1709 + case FC_WCHAR: 1710 + case FC_SHORT: 1711 + param_type = FC_SHORT; 1701 1712 break; 1702 - case RPC_FC_USHORT: 1703 - param_type = RPC_FC_USHORT; 1713 + case FC_USHORT: 1714 + param_type = FC_USHORT; 1704 1715 break; 1705 - case RPC_FC_LONG: 1706 - param_type = RPC_FC_LONG; 1716 + case FC_LONG: 1717 + param_type = FC_LONG; 1707 1718 break; 1708 - case RPC_FC_ULONG: 1709 - param_type = RPC_FC_ULONG; 1719 + case FC_ULONG: 1720 + param_type = FC_ULONG; 1710 1721 break; 1711 1722 default: 1712 1723 error("write_conf_or_var_desc: conformance variable type not supported 0x%x\n", ··· 1715 1726 } 1716 1727 else if (type_get_type(correlation_variable) == TYPE_ENUM) 1717 1728 { 1718 - if (get_enum_fc(correlation_variable) == RPC_FC_ENUM32) 1719 - param_type = RPC_FC_LONG; 1729 + if (get_enum_fc(correlation_variable) == FC_ENUM32) 1730 + param_type = FC_LONG; 1720 1731 else 1721 - param_type = RPC_FC_SHORT; 1732 + param_type = FC_SHORT; 1722 1733 } 1723 1734 else if (type_get_type(correlation_variable) == TYPE_POINTER) 1724 1735 { 1725 1736 if (pointer_size == 8) 1726 - param_type = RPC_FC_HYPER; 1737 + param_type = FC_HYPER; 1727 1738 else 1728 - param_type = RPC_FC_LONG; 1739 + param_type = FC_LONG; 1729 1740 } 1730 1741 else 1731 1742 { ··· 1776 1787 error("Maximum number of callback routines reached\n"); 1777 1788 1778 1789 print_file(file, 2, "0x%x,\t/* Corr desc: %s in %s */\n", conftype, conftype_string, name); 1779 - print_file(file, 2, "0x%x,\t/* %s */\n", RPC_FC_CALLBACK, "FC_CALLBACK"); 1790 + print_file(file, 2, "0x%x,\t/* %s */\n", FC_CALLBACK, "FC_CALLBACK"); 1780 1791 print_file(file, 2, "NdrFcShort(0x%hx),\t/* %u */\n", (unsigned short)callback_offset, callback_offset); 1781 1792 } 1782 1793 else /* output a dummy corr desc that isn't used */ ··· 1841 1852 return maxs; 1842 1853 } 1843 1854 1844 - static unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align) 1855 + unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align) 1845 1856 { 1846 1857 unsigned int size = 0; 1847 1858 ··· 1850 1861 case TYPE_BASIC: 1851 1862 switch (get_basic_fc(t)) 1852 1863 { 1853 - case RPC_FC_BYTE: 1854 - case RPC_FC_CHAR: 1855 - case RPC_FC_USMALL: 1856 - case RPC_FC_SMALL: 1864 + case FC_BYTE: 1865 + case FC_CHAR: 1866 + case FC_USMALL: 1867 + case FC_SMALL: 1857 1868 size = 1; 1858 1869 if (size > *align) *align = size; 1859 1870 break; 1860 - case RPC_FC_WCHAR: 1861 - case RPC_FC_USHORT: 1862 - case RPC_FC_SHORT: 1871 + case FC_WCHAR: 1872 + case FC_USHORT: 1873 + case FC_SHORT: 1863 1874 size = 2; 1864 1875 if (size > *align) *align = size; 1865 1876 break; 1866 - case RPC_FC_ULONG: 1867 - case RPC_FC_LONG: 1868 - case RPC_FC_ERROR_STATUS_T: 1869 - case RPC_FC_FLOAT: 1877 + case FC_ULONG: 1878 + case FC_LONG: 1879 + case FC_ERROR_STATUS_T: 1880 + case FC_FLOAT: 1870 1881 size = 4; 1871 1882 if (size > *align) *align = size; 1872 1883 break; 1873 - case RPC_FC_HYPER: 1874 - case RPC_FC_DOUBLE: 1884 + case FC_HYPER: 1885 + case FC_DOUBLE: 1875 1886 size = 8; 1876 1887 if (size > *align) *align = size; 1877 1888 break; 1878 - case RPC_FC_INT3264: 1879 - case RPC_FC_UINT3264: 1880 - case RPC_FC_BIND_PRIMITIVE: 1889 + case FC_INT3264: 1890 + case FC_UINT3264: 1891 + case FC_BIND_PRIMITIVE: 1881 1892 assert( pointer_size ); 1882 1893 size = pointer_size; 1883 1894 if (size > *align) *align = size; ··· 1890 1901 case TYPE_ENUM: 1891 1902 switch (get_enum_fc(t)) 1892 1903 { 1893 - case RPC_FC_ENUM16: 1894 - case RPC_FC_ENUM32: 1904 + case FC_ENUM16: 1905 + case FC_ENUM32: 1895 1906 size = 4; 1896 1907 if (size > *align) *align = size; 1897 1908 break; ··· 1910 1921 size = union_memsize(type_union_get_cases(t), align); 1911 1922 break; 1912 1923 case TYPE_POINTER: 1924 + case TYPE_INTERFACE: 1913 1925 assert( pointer_size ); 1914 1926 size = pointer_size; 1915 1927 if (size > *align) *align = size; ··· 1933 1945 if (size > *align) *align = size; 1934 1946 } 1935 1947 break; 1936 - case TYPE_INTERFACE: 1937 1948 case TYPE_ALIAS: 1938 1949 case TYPE_VOID: 1939 1950 case TYPE_COCLASS: ··· 1967 1978 case TYPE_BASIC: 1968 1979 switch (get_basic_fc(t)) 1969 1980 { 1970 - case RPC_FC_BYTE: 1971 - case RPC_FC_CHAR: 1972 - case RPC_FC_USMALL: 1973 - case RPC_FC_SMALL: 1981 + case FC_BYTE: 1982 + case FC_CHAR: 1983 + case FC_USMALL: 1984 + case FC_SMALL: 1974 1985 return 1; 1975 - case RPC_FC_WCHAR: 1976 - case RPC_FC_USHORT: 1977 - case RPC_FC_SHORT: 1986 + case FC_WCHAR: 1987 + case FC_USHORT: 1988 + case FC_SHORT: 1978 1989 return 2; 1979 - case RPC_FC_ULONG: 1980 - case RPC_FC_LONG: 1981 - case RPC_FC_ERROR_STATUS_T: 1982 - case RPC_FC_FLOAT: 1983 - case RPC_FC_INT3264: 1984 - case RPC_FC_UINT3264: 1990 + case FC_ULONG: 1991 + case FC_LONG: 1992 + case FC_ERROR_STATUS_T: 1993 + case FC_FLOAT: 1994 + case FC_INT3264: 1995 + case FC_UINT3264: 1985 1996 return 4; 1986 - case RPC_FC_HYPER: 1987 - case RPC_FC_DOUBLE: 1997 + case FC_HYPER: 1998 + case FC_DOUBLE: 1988 1999 return 8; 1989 2000 default: 1990 2001 error("type_buffer_alignment: Unknown type 0x%x\n", get_basic_fc(t)); ··· 1993 2004 case TYPE_ENUM: 1994 2005 switch (get_enum_fc(t)) 1995 2006 { 1996 - case RPC_FC_ENUM16: 2007 + case FC_ENUM16: 1997 2008 return 2; 1998 - case RPC_FC_ENUM32: 2009 + case FC_ENUM32: 1999 2010 return 4; 2000 2011 default: 2001 2012 error("type_buffer_alignment: Unknown enum type\n"); ··· 2094 2105 out_attr = is_attr(attrs, ATTR_OUT); 2095 2106 if (!in_attr && !out_attr) in_attr = 1; 2096 2107 2097 - if (out_attr && !in_attr && pointer_type == RPC_FC_RP) 2098 - flags |= RPC_FC_P_ONSTACK; 2108 + if (!is_interpreted_func(current_iface, current_func)) 2109 + { 2110 + if (out_attr && !in_attr && pointer_type == FC_RP) 2111 + flags |= FC_ALLOCED_ON_STACK; 2112 + } 2113 + else if (get_stub_mode() == MODE_Oif) 2114 + { 2115 + if (context == TYPE_CONTEXT_TOPLEVELPARAM && is_ptr(type) && pointer_type == FC_RP) 2116 + { 2117 + switch (typegen_detect_type(type_pointer_get_ref(type), NULL, TDT_ALL_TYPES)) 2118 + { 2119 + case TGT_STRING: 2120 + case TGT_POINTER: 2121 + case TGT_CTXT_HANDLE: 2122 + case TGT_CTXT_HANDLE_POINTER: 2123 + flags |= FC_ALLOCED_ON_STACK; 2124 + break; 2125 + case TGT_IFACE_POINTER: 2126 + if (in_attr && out_attr) 2127 + flags |= FC_ALLOCED_ON_STACK; 2128 + break; 2129 + default: 2130 + break; 2131 + } 2132 + } 2133 + } 2099 2134 2100 2135 if (is_ptr(type)) 2101 2136 { 2102 2137 type_t *ref = type_pointer_get_ref(type); 2103 2138 if(is_declptr(ref) && !is_user_type(ref)) 2104 - flags |= RPC_FC_P_DEREF; 2139 + flags |= FC_POINTER_DEREF; 2105 2140 } 2106 2141 2107 2142 print_file(file, 2, "0x%x, 0x%x,\t\t/* %s", ··· 2110 2145 string_of_type(pointer_type)); 2111 2146 if (file) 2112 2147 { 2113 - if (flags & RPC_FC_P_ONSTACK) 2148 + if (flags & FC_ALLOCED_ON_STACK) 2114 2149 fprintf(file, " [allocated_on_stack]"); 2115 - if (flags & RPC_FC_P_DEREF) 2150 + if (flags & FC_POINTER_DEREF) 2116 2151 fprintf(file, " [pointer_deref]"); 2117 2152 fprintf(file, " */\n"); 2118 2153 } ··· 2131 2166 const type_t *ref; 2132 2167 int in_attr = is_attr(attrs, ATTR_IN); 2133 2168 int out_attr = is_attr(attrs, ATTR_OUT); 2134 - unsigned char flags = RPC_FC_P_SIMPLEPOINTER; 2169 + unsigned char flags = FC_SIMPLE_POINTER; 2135 2170 2136 2171 /* for historical reasons, write_simple_pointer also handled string types, 2137 2172 * but no longer does. catch bad uses of the function with this check */ ··· 2146 2181 else 2147 2182 fc = get_basic_fc(ref); 2148 2183 2149 - if (out_attr && !in_attr) 2150 - flags |= RPC_FC_P_ONSTACK; 2184 + if (!is_interpreted_func(current_iface, current_func)) 2185 + { 2186 + if (out_attr && !in_attr && pointer_fc == FC_RP) 2187 + flags |= FC_ALLOCED_ON_STACK; 2188 + } 2189 + else if (get_stub_mode() == MODE_Oif) 2190 + { 2191 + if (context == TYPE_CONTEXT_TOPLEVELPARAM && fc == FC_ENUM16 && pointer_fc == FC_RP) 2192 + flags |= FC_ALLOCED_ON_STACK; 2193 + } 2151 2194 2152 2195 print_file(file, 2, "0x%02x, 0x%x,\t/* %s %s[simple_pointer] */\n", 2153 2196 pointer_fc, flags, string_of_type(pointer_fc), 2154 - flags & RPC_FC_P_ONSTACK ? "[allocated_on_stack] " : ""); 2197 + flags & FC_ALLOCED_ON_STACK ? "[allocated_on_stack] " : ""); 2155 2198 print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc)); 2156 2199 print_file(file, 2, "0x5c,\t/* FC_PAD */\n"); 2157 2200 return 4; ··· 2203 2246 { 2204 2247 switch (get_struct_fc(t)) 2205 2248 { 2206 - case RPC_FC_PSTRUCT: 2207 - case RPC_FC_CSTRUCT: 2208 - case RPC_FC_CPSTRUCT: 2209 - case RPC_FC_CVSTRUCT: 2249 + case FC_PSTRUCT: 2250 + case FC_CSTRUCT: 2251 + case FC_CPSTRUCT: 2252 + case FC_CVSTRUCT: 2210 2253 return TRUE; 2211 2254 } 2212 2255 } ··· 2255 2298 absoff = utype->typestring_offset; 2256 2299 } 2257 2300 2258 - if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == RPC_FC_RP) 2301 + if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == FC_RP) 2259 2302 flags = 0x40; 2260 - else if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == RPC_FC_UP) 2303 + else if (type_get_type(utype) == TYPE_POINTER && get_pointer_fc(utype, NULL, FALSE) == FC_UP) 2261 2304 flags = 0x80; 2262 2305 else 2263 2306 flags = 0; ··· 2265 2308 start = *tfsoff; 2266 2309 update_tfsoff(type, start, file); 2267 2310 print_start_tfs_comment(file, type, start); 2268 - print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", RPC_FC_USER_MARSHAL); 2311 + print_file(file, 2, "0x%x,\t/* FC_USER_MARSHAL */\n", FC_USER_MARSHAL); 2269 2312 print_file(file, 2, "0x%x,\t/* Alignment= %d, Flags= %02x */\n", 2270 2313 flags | (ualign - 1), ualign - 1, flags); 2271 2314 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Function offset= %hu */\n", funoff, funoff); ··· 2310 2353 } 2311 2354 else if (is_ptr(type) || is_conformant_array(type)) 2312 2355 { 2313 - unsigned char fc = cont_is_complex ? RPC_FC_POINTER : RPC_FC_LONG; 2356 + unsigned char fc = cont_is_complex ? FC_POINTER : FC_LONG; 2314 2357 print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc)); 2315 2358 *tfsoff += 1; 2316 2359 } ··· 2352 2395 { 2353 2396 if (*tfsoff % 2 == 0) 2354 2397 { 2355 - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); 2398 + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); 2356 2399 *tfsoff += 1; 2357 2400 } 2358 - print_file(file, 2, "0x%x,\t/* FC_END */\n", RPC_FC_END); 2401 + print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END); 2359 2402 *tfsoff += 1; 2360 2403 } 2361 2404 ··· 2377 2420 absoff += 8; /* we already have a corr descr, skip it */ 2378 2421 reloff = absoff - (*tfsoff + 6); 2379 2422 print_file(file, 0, "/* %d */\n", *tfsoff); 2380 - print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION); 2381 - print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", RPC_FC_LONG); 2423 + print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", FC_NON_ENCAPSULATED_UNION); 2424 + print_file(file, 2, "0x%x,\t/* FIXME: always FC_LONG */\n", FC_LONG); 2382 2425 write_conf_or_var_desc(file, current_structure, offset, ft, 2383 2426 get_attrp(f->attrs, ATTR_SWITCHIS)); 2384 2427 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", ··· 2497 2540 if (is_ptr(type) || 2498 2541 (is_conformant_array(type) && type_array_is_decl_as_ptr(type))) 2499 2542 { 2500 - print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", RPC_FC_NO_REPEAT); 2501 - print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD); 2543 + print_file(file, 2, "0x%02x, /* FC_NO_REPEAT */\n", FC_NO_REPEAT); 2544 + print_file(file, 2, "0x%02x, /* FC_PAD */\n", FC_PAD); 2502 2545 *typestring_offset += 2; 2503 2546 2504 2547 return write_pointer_description_offsets(file, attrs, type, ··· 2561 2604 2562 2605 increment_size = type_memsize(type_array_get_element(type)); 2563 2606 2564 - print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", RPC_FC_FIXED_REPEAT); 2565 - print_file(file, 2, "0x%02x, /* FC_PAD */\n", RPC_FC_PAD); 2607 + print_file(file, 2, "0x%02x, /* FC_FIXED_REPEAT */\n", FC_FIXED_REPEAT); 2608 + print_file(file, 2, "0x%02x, /* FC_PAD */\n", FC_PAD); 2566 2609 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Iterations = %d */\n", (unsigned short)type_array_get_dim(type), type_array_get_dim(type)); 2567 2610 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size); 2568 2611 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory); ··· 2635 2678 if (increment_size > USHRT_MAX) 2636 2679 error("array size of %u bytes is too large\n", increment_size); 2637 2680 2638 - print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT); 2639 - print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", RPC_FC_FIXED_OFFSET); 2681 + print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", FC_VARIABLE_REPEAT); 2682 + print_file(file, 2, "0x%02x, /* FC_FIXED_OFFSET */\n", FC_FIXED_OFFSET); 2640 2683 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size); 2641 2684 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)offset_in_memory, offset_in_memory); 2642 2685 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count); ··· 2677 2720 if (increment_size > USHRT_MAX) 2678 2721 error("array size of %u bytes is too large\n", increment_size); 2679 2722 2680 - print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", RPC_FC_VARIABLE_REPEAT); 2681 - print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", RPC_FC_VARIABLE_OFFSET); 2723 + print_file(file, 2, "0x%02x, /* FC_VARIABLE_REPEAT */\n", FC_VARIABLE_REPEAT); 2724 + print_file(file, 2, "0x%02x, /* FC_VARIABLE_OFFSET */\n", FC_VARIABLE_OFFSET); 2682 2725 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Increment = %d */\n", (unsigned short)increment_size, increment_size); 2683 2726 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset to array = %d */\n", (unsigned short)*offset_in_memory, *offset_in_memory); 2684 2727 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Number of pointers = %d */\n", (unsigned short)pointer_count, pointer_count); ··· 2761 2804 write_conformant_array_pointer_descriptions( 2762 2805 file, attrs, type, 0, typestring_offset); 2763 2806 else if (type_get_type(type) == TYPE_STRUCT && 2764 - get_struct_fc(type) == RPC_FC_CPSTRUCT) 2807 + get_struct_fc(type) == FC_CPSTRUCT) 2765 2808 { 2766 2809 type_t *carray = find_array_or_string_in_struct(type)->type; 2767 2810 write_conformant_array_pointer_descriptions( file, NULL, carray, ··· 2789 2832 2790 2833 if (is_declptr(type)) 2791 2834 { 2792 - unsigned char flag = is_conformant_array(type) ? 0 : RPC_FC_P_SIMPLEPOINTER; 2835 + unsigned char flag = is_conformant_array(type) ? 0 : FC_SIMPLE_POINTER; 2793 2836 int pointer_type = get_pointer_fc_context(type, attrs, context); 2794 2837 if (!pointer_type) 2795 - pointer_type = RPC_FC_RP; 2838 + pointer_type = FC_RP; 2796 2839 print_start_tfs_comment(file, type, *typestring_offset); 2797 2840 print_file(file, 2,"0x%x, 0x%x,\t/* %s%s */\n", 2798 2841 pointer_type, flag, string_of_type(pointer_type), ··· 2821 2864 } 2822 2865 2823 2866 rtype = get_basic_fc(elem_type); 2824 - if ((rtype != RPC_FC_BYTE) && (rtype != RPC_FC_CHAR) && (rtype != RPC_FC_WCHAR)) 2867 + if ((rtype != FC_BYTE) && (rtype != FC_CHAR) && (rtype != FC_WCHAR)) 2825 2868 { 2826 2869 error("write_string_tfs: Unimplemented for type 0x%x of name: %s\n", rtype, name); 2827 2870 return start_offset; ··· 2838 2881 error("array size for parameter %s exceeds %u bytes by %u bytes\n", 2839 2882 name, 0xffffu, dim - 0xffffu); 2840 2883 2841 - if (rtype == RPC_FC_WCHAR) 2884 + if (rtype == FC_WCHAR) 2842 2885 WRITE_FCTYPE(file, FC_WSTRING, *typestring_offset); 2843 2886 else 2844 2887 WRITE_FCTYPE(file, FC_CSTRING, *typestring_offset); 2845 - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); 2888 + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); 2846 2889 *typestring_offset += 2; 2847 2890 2848 2891 print_file(file, 2, "NdrFcShort(0x%hx),\t/* %d */\n", (unsigned short)dim, dim); ··· 2853 2896 } 2854 2897 else if (is_conformant_array(type)) 2855 2898 { 2856 - if (rtype == RPC_FC_WCHAR) 2899 + if (rtype == FC_WCHAR) 2857 2900 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset); 2858 2901 else 2859 2902 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset); 2860 - print_file(file, 2, "0x%x,\t/* FC_STRING_SIZED */\n", RPC_FC_STRING_SIZED); 2903 + print_file(file, 2, "0x%x,\t/* FC_STRING_SIZED */\n", FC_STRING_SIZED); 2861 2904 *typestring_offset += 2; 2862 2905 2863 2906 *typestring_offset += write_conf_or_var_desc( ··· 2874 2917 { 2875 2918 if (is_processed) return start_offset; 2876 2919 2877 - if (rtype == RPC_FC_WCHAR) 2920 + if (rtype == FC_WCHAR) 2878 2921 WRITE_FCTYPE(file, FC_C_WSTRING, *typestring_offset); 2879 2922 else 2880 2923 WRITE_FCTYPE(file, FC_C_CSTRING, *typestring_offset); 2881 - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); 2924 + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); 2882 2925 *typestring_offset += 2; 2883 2926 2884 2927 update_tfsoff(type, start_offset, file); ··· 2902 2945 : 0; 2903 2946 2904 2947 if (!pointer_type) 2905 - pointer_type = RPC_FC_RP; 2948 + pointer_type = FC_RP; 2906 2949 2907 2950 if (!is_string_type(attrs, type_array_get_element(type))) 2908 2951 write_embedded_types(file, attrs, type_array_get_element(type), name, FALSE, typestring_offset); ··· 2919 2962 *typestring_offset += 2; 2920 2963 2921 2964 align = 0; 2922 - if (fc != RPC_FC_BOGUS_ARRAY) 2965 + if (fc != FC_BOGUS_ARRAY) 2923 2966 { 2924 - if (fc == RPC_FC_LGFARRAY || fc == RPC_FC_LGVARRAY) 2967 + if (fc == FC_LGFARRAY || fc == FC_LGVARRAY) 2925 2968 { 2926 2969 print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", size, size); 2927 2970 *typestring_offset += 4; ··· 2937 2980 += write_conf_or_var_desc(file, current_structure, baseoff, 2938 2981 type, size_is); 2939 2982 2940 - if (fc == RPC_FC_SMVARRAY || fc == RPC_FC_LGVARRAY) 2983 + if (fc == FC_SMVARRAY || fc == FC_LGVARRAY) 2941 2984 { 2942 2985 unsigned int elsize = type_memsize(type_array_get_element(type)); 2943 2986 unsigned int dim = type_array_get_dim(type); 2944 2987 2945 - if (fc == RPC_FC_LGVARRAY) 2988 + if (fc == FC_LGVARRAY) 2946 2989 { 2947 2990 print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", dim, dim); 2948 2991 *typestring_offset += 4; ··· 2965 3008 if (type_has_pointers(type_array_get_element(type)) && 2966 3009 (type_array_is_decl_as_ptr(type) || !current_structure)) 2967 3010 { 2968 - print_file(file, 2, "0x%x,\t/* FC_PP */\n", RPC_FC_PP); 2969 - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); 3011 + print_file(file, 2, "0x%x,\t/* FC_PP */\n", FC_PP); 3012 + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); 2970 3013 *typestring_offset += 2; 2971 3014 write_pointer_description(file, is_string_type(attrs, type) ? attrs : NULL, type, typestring_offset); 2972 - print_file(file, 2, "0x%x,\t/* FC_END */\n", RPC_FC_END); 3015 + print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END); 2973 3016 *typestring_offset += 1; 2974 3017 } 2975 3018 ··· 3042 3085 switch (align) 3043 3086 { 3044 3087 case 2: 3045 - fc = RPC_FC_ALIGNM2; 3088 + fc = FC_ALIGNM2; 3046 3089 break; 3047 3090 case 4: 3048 - fc = RPC_FC_ALIGNM4; 3091 + fc = FC_ALIGNM4; 3049 3092 break; 3050 3093 case 8: 3051 - fc = RPC_FC_ALIGNM8; 3094 + fc = FC_ALIGNM8; 3052 3095 break; 3053 3096 default: 3054 3097 error("write_struct_members: cannot align type %d\n", type_get_type(ft)); ··· 3067 3110 if (padding) 3068 3111 { 3069 3112 print_file(file, 2, "0x%x,\t/* FC_STRUCTPAD%d */\n", 3070 - RPC_FC_STRUCTPAD1 + padding - 1, 3113 + FC_STRUCTPAD1 + padding - 1, 3071 3114 padding); 3072 3115 *typestring_offset += 1; 3073 3116 } ··· 3130 3173 reloff, reloff, absoff); 3131 3174 *tfsoff += 2; 3132 3175 } 3133 - else if (fc == RPC_FC_BOGUS_STRUCT) 3176 + else if (fc == FC_BOGUS_STRUCT) 3134 3177 { 3135 3178 print_file(file, 2, "NdrFcShort(0x0),\n"); 3136 3179 *tfsoff += 2; 3137 3180 } 3138 3181 3139 - if (fc == RPC_FC_BOGUS_STRUCT) 3182 + if (fc == FC_BOGUS_STRUCT) 3140 3183 { 3141 3184 /* On the sizing pass, type->ptrdesc may be zero, but it's ok as 3142 3185 nothing is written to file yet. On the actual writing pass, ··· 3148 3191 (unsigned short)reloff, reloff, absoff); 3149 3192 *tfsoff += 2; 3150 3193 } 3151 - else if ((fc == RPC_FC_PSTRUCT) || 3152 - (fc == RPC_FC_CPSTRUCT) || 3153 - (fc == RPC_FC_CVSTRUCT && type_has_pointers(type))) 3194 + else if ((fc == FC_PSTRUCT) || 3195 + (fc == FC_CPSTRUCT) || 3196 + (fc == FC_CVSTRUCT && type_has_pointers(type))) 3154 3197 { 3155 - print_file(file, 2, "0x%x,\t/* FC_PP */\n", RPC_FC_PP); 3156 - print_file(file, 2, "0x%x,\t/* FC_PAD */\n", RPC_FC_PAD); 3198 + print_file(file, 2, "0x%x,\t/* FC_PP */\n", FC_PP); 3199 + print_file(file, 2, "0x%x,\t/* FC_PAD */\n", FC_PAD); 3157 3200 *tfsoff += 2; 3158 3201 write_pointer_description(file, NULL, type, tfsoff); 3159 - print_file(file, 2, "0x%x,\t/* FC_END */\n", RPC_FC_END); 3202 + print_file(file, 2, "0x%x,\t/* FC_END */\n", FC_END); 3160 3203 *tfsoff += 1; 3161 3204 } 3162 3205 3163 - write_struct_members(file, type, fc == RPC_FC_BOGUS_STRUCT, &corroff, 3206 + write_struct_members(file, type, fc == FC_BOGUS_STRUCT, &corroff, 3164 3207 tfsoff); 3165 3208 3166 - if (fc == RPC_FC_BOGUS_STRUCT) 3209 + if (fc == FC_BOGUS_STRUCT) 3167 3210 { 3168 3211 const var_t *f; 3169 3212 ··· 3248 3291 unsigned int nbranch = 0; 3249 3292 type_t *deftype = NULL; 3250 3293 short nodeftype = 0xffff; 3294 + unsigned int dummy; 3251 3295 var_t *f; 3252 3296 3253 3297 if (processed(type) && ··· 3256 3300 3257 3301 guard_rec(type); 3258 3302 3259 - size = type_memsize(type); 3260 - 3261 3303 fields = type_union_get_cases(type); 3304 + 3305 + size = union_memsize(fields, &dummy); 3262 3306 3263 3307 if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) 3264 3308 { ··· 3276 3320 { 3277 3321 const var_t *sv = type_union_get_switch_value(type); 3278 3322 const type_t *st = sv->type; 3323 + unsigned int align = 0; 3279 3324 unsigned char fc; 3280 3325 3281 3326 if (type_get_type(st) == TYPE_BASIC) ··· 3283 3328 fc = get_basic_fc(st); 3284 3329 switch (fc) 3285 3330 { 3286 - case RPC_FC_CHAR: 3287 - case RPC_FC_SMALL: 3288 - case RPC_FC_BYTE: 3289 - case RPC_FC_USMALL: 3290 - case RPC_FC_WCHAR: 3291 - case RPC_FC_SHORT: 3292 - case RPC_FC_USHORT: 3293 - case RPC_FC_LONG: 3294 - case RPC_FC_ULONG: 3331 + case FC_CHAR: 3332 + case FC_SMALL: 3333 + case FC_BYTE: 3334 + case FC_USMALL: 3335 + case FC_WCHAR: 3336 + case FC_SHORT: 3337 + case FC_USHORT: 3338 + case FC_LONG: 3339 + case FC_ULONG: 3295 3340 break; 3296 3341 default: 3297 3342 fc = 0; ··· 3303 3348 else 3304 3349 error("union switch type must be an integer, char, or enum\n"); 3305 3350 3306 - print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", RPC_FC_ENCAPSULATED_UNION); 3351 + type_memsize_and_alignment(st, &align); 3352 + if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) 3353 + { 3354 + if (f->type) 3355 + type_memsize_and_alignment(f->type, &align); 3356 + } 3357 + 3358 + print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", FC_ENCAPSULATED_UNION); 3307 3359 print_file(file, 2, "0x%x,\t/* Switch type= %s */\n", 3308 - 0x40 | fc, string_of_type(fc)); 3360 + (align << 4) | fc, string_of_type(fc)); 3309 3361 *tfsoff += 2; 3310 3362 } 3311 3363 else if (is_attr(type->attrs, ATTR_SWITCHTYPE)) ··· 3319 3371 fc = get_basic_fc(st); 3320 3372 switch (fc) 3321 3373 { 3322 - case RPC_FC_CHAR: 3323 - case RPC_FC_SMALL: 3324 - case RPC_FC_USMALL: 3325 - case RPC_FC_SHORT: 3326 - case RPC_FC_USHORT: 3327 - case RPC_FC_LONG: 3328 - case RPC_FC_ULONG: 3329 - case RPC_FC_ENUM16: 3330 - case RPC_FC_ENUM32: 3374 + case FC_CHAR: 3375 + case FC_SMALL: 3376 + case FC_USMALL: 3377 + case FC_SHORT: 3378 + case FC_USHORT: 3379 + case FC_LONG: 3380 + case FC_ULONG: 3381 + case FC_ENUM16: 3382 + case FC_ENUM32: 3331 3383 break; 3332 3384 default: 3333 3385 fc = 0; ··· 3339 3391 else 3340 3392 error("union switch type must be an integer, char, or enum\n"); 3341 3393 3342 - print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", RPC_FC_NON_ENCAPSULATED_UNION); 3394 + print_file(file, 2, "0x%x,\t/* FC_NON_ENCAPSULATED_UNION */\n", FC_NON_ENCAPSULATED_UNION); 3343 3395 print_file(file, 2, "0x%x,\t/* Switch type= %s */\n", 3344 3396 fc, string_of_type(fc)); 3345 3397 *tfsoff += 2; ··· 3453 3505 if (flags & 0x80) /* via ptr */ 3454 3506 { 3455 3507 int pointer_type = get_pointer_fc( type, attrs, toplevel_param ); 3456 - if (!pointer_type) pointer_type = RPC_FC_RP; 3508 + if (!pointer_type) pointer_type = FC_RP; 3457 3509 *typeformat_offset += 4; 3458 3510 print_file(file, 2,"0x%x, 0x0,\t/* %s */\n", pointer_type, string_of_type(pointer_type) ); 3459 3511 print_file(file, 2, "NdrFcShort(0x2),\t /* Offset= 2 (%u) */\n", *typeformat_offset); 3460 3512 print_file(file, 0, "/* %2u */\n", *typeformat_offset); 3461 3513 } 3462 3514 3463 - print_file(file, 2, "0x%02x,\t/* FC_BIND_CONTEXT */\n", RPC_FC_BIND_CONTEXT); 3515 + print_file(file, 2, "0x%02x,\t/* FC_BIND_CONTEXT */\n", FC_BIND_CONTEXT); 3464 3516 print_file(file, 2, "0x%x,\t/* Context flags: ", flags); 3465 3517 /* return and can't be null values overlap */ 3466 3518 if (((flags & 0x21) != 0x21) && (flags & NDR_CONTEXT_HANDLE_CANNOT_BE_NULL)) 3467 3519 print_file(file, 0, "can't be null, "); 3468 3520 if (flags & NDR_CONTEXT_HANDLE_SERIALIZE) 3469 3521 print_file(file, 0, "serialize, "); 3470 - if (flags & NDR_CONTEXT_HANDLE_NO_SERIALIZE) 3522 + if (flags & NDR_CONTEXT_HANDLE_NOSERIALIZE) 3471 3523 print_file(file, 0, "no serialize, "); 3472 3524 if (flags & NDR_STRICT_CONTEXT_HANDLE) 3473 3525 print_file(file, 0, "strict, "); ··· 3506 3558 assert(fc <= 0xf); 3507 3559 3508 3560 print_file(file, 0, "/* %u */\n", *typeformat_offset); 3509 - print_file(file, 2, "0x%x,\t/* FC_RANGE */\n", RPC_FC_RANGE); 3561 + print_file(file, 2, "0x%x,\t/* FC_RANGE */\n", FC_RANGE); 3510 3562 print_file(file, 2, "0x%x,\t/* %s */\n", fc, string_of_type(fc)); 3511 3563 print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", range_min->cval, range_min->cval); 3512 3564 print_file(file, 2, "NdrFcLong(0x%x),\t/* %u */\n", range_max->cval, range_max->cval); ··· 3550 3602 int ptr_type; 3551 3603 ptr_type = get_pointer_fc(type, attrs, 3552 3604 context == TYPE_CONTEXT_TOPLEVELPARAM); 3553 - if (ptr_type != RPC_FC_RP || type_array_is_decl_as_ptr(type)) 3605 + if (ptr_type != FC_RP || type_array_is_decl_as_ptr(type)) 3554 3606 { 3555 3607 unsigned int absoff = type->typestring_offset; 3556 3608 short reloff = absoff - (*typeformat_offset + 2); ··· 3560 3612 string_of_type(ptr_type)); 3561 3613 print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", 3562 3614 reloff, reloff, absoff); 3563 - if (ptr_type != RPC_FC_RP) update_tfsoff( type, off, file ); 3615 + if (ptr_type != FC_RP) update_tfsoff( type, off, file ); 3564 3616 *typeformat_offset += 4; 3565 3617 } 3566 3618 type->details.array.ptr_tfsoff = off; ··· 3626 3678 return write_type_tfs(file, 2, attrs, type, name, write_ptr ? TYPE_CONTEXT_CONTAINER : TYPE_CONTEXT_CONTAINER_NO_POINTERS, tfsoff); 3627 3679 } 3628 3680 3629 - static unsigned int process_tfs_stmts(FILE *file, const statement_list_t *stmts, 3630 - type_pred_t pred, unsigned int *typeformat_offset) 3681 + static void process_tfs_iface(type_t *iface, FILE *file, int indent, unsigned int *offset) 3631 3682 { 3632 - var_t *var; 3683 + const statement_list_t *stmts = type_iface_get_stmts(iface); 3633 3684 const statement_t *stmt; 3685 + var_t *var; 3634 3686 3635 - if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) 3687 + current_iface = iface; 3688 + if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry ) 3636 3689 { 3637 - const type_t *iface; 3638 - const statement_t *stmt_func; 3639 - 3640 - if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) 3641 - continue; 3690 + switch(stmt->type) 3691 + { 3692 + case STMT_DECLARATION: 3693 + { 3694 + const var_t *func = stmt->u.var; 3642 3695 3643 - iface = stmt->u.type; 3644 - if (!pred(iface)) 3645 - continue; 3696 + if(stmt->u.var->stgclass != STG_NONE 3697 + || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION) 3698 + continue; 3646 3699 3647 - current_iface = iface; 3648 - STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(iface) ) 3649 - { 3650 - const var_t *func = stmt_func->u.var; 3651 3700 current_func = func; 3652 3701 if (is_local(func->attrs)) continue; 3653 3702 3654 3703 var = type_function_get_retval(func->type); 3655 3704 if (!is_void(var->type)) 3656 3705 var->typestring_offset = write_type_tfs( file, 2, func->attrs, var->type, func->name, 3657 - TYPE_CONTEXT_PARAM, typeformat_offset); 3706 + TYPE_CONTEXT_PARAM, offset); 3658 3707 3659 3708 if (type_get_function_args(func->type)) 3660 3709 LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), var_t, entry ) 3661 3710 var->typestring_offset = write_type_tfs( file, 2, var->attrs, var->type, var->name, 3662 - TYPE_CONTEXT_TOPLEVELPARAM, 3663 - typeformat_offset ); 3711 + TYPE_CONTEXT_TOPLEVELPARAM, offset ); 3712 + break; 3713 + 3714 + } 3715 + case STMT_TYPEDEF: 3716 + { 3717 + const type_list_t *type_entry; 3718 + for (type_entry = stmt->u.type_list; type_entry; type_entry = type_entry->next) 3719 + { 3720 + if (is_attr(type_entry->type->attrs, ATTR_ENCODE) 3721 + || is_attr(type_entry->type->attrs, ATTR_DECODE)) 3722 + type_entry->type->typestring_offset = write_type_tfs( file, 2, 3723 + type_entry->type->attrs, type_entry->type, type_entry->type->name, 3724 + TYPE_CONTEXT_CONTAINER, offset); 3725 + } 3726 + break; 3727 + } 3728 + default: 3729 + break; 3664 3730 } 3665 3731 } 3666 - 3667 - return *typeformat_offset + 1; 3668 3732 } 3669 3733 3670 3734 static unsigned int process_tfs(FILE *file, const statement_list_t *stmts, type_pred_t pred) 3671 3735 { 3672 3736 unsigned int typeformat_offset = 2; 3673 - 3674 - return process_tfs_stmts(file, stmts, pred, &typeformat_offset); 3737 + for_each_iface(stmts, process_tfs_iface, pred, file, 0, &typeformat_offset); 3738 + return typeformat_offset + 1; 3675 3739 } 3676 3740 3677 3741 ··· 3706 3770 { 3707 3771 case TGT_USER_TYPE: 3708 3772 { 3709 - const char *uname; 3773 + const char *uname = NULL; 3710 3774 const type_t *utype = get_user_type(type, &uname); 3711 3775 return get_required_buffer_size_type(utype, uname, NULL, FALSE, alignment); 3712 3776 } 3713 3777 case TGT_BASIC: 3714 3778 switch (get_basic_fc(type)) 3715 3779 { 3716 - case RPC_FC_BYTE: 3717 - case RPC_FC_CHAR: 3718 - case RPC_FC_USMALL: 3719 - case RPC_FC_SMALL: 3780 + case FC_BYTE: 3781 + case FC_CHAR: 3782 + case FC_USMALL: 3783 + case FC_SMALL: 3720 3784 *alignment = 4; 3721 3785 return 1; 3722 3786 3723 - case RPC_FC_WCHAR: 3724 - case RPC_FC_USHORT: 3725 - case RPC_FC_SHORT: 3787 + case FC_WCHAR: 3788 + case FC_USHORT: 3789 + case FC_SHORT: 3726 3790 *alignment = 4; 3727 3791 return 2; 3728 3792 3729 - case RPC_FC_ULONG: 3730 - case RPC_FC_LONG: 3731 - case RPC_FC_FLOAT: 3732 - case RPC_FC_ERROR_STATUS_T: 3793 + case FC_ULONG: 3794 + case FC_LONG: 3795 + case FC_FLOAT: 3796 + case FC_ERROR_STATUS_T: 3733 3797 *alignment = 4; 3734 3798 return 4; 3735 3799 3736 - case RPC_FC_HYPER: 3737 - case RPC_FC_DOUBLE: 3800 + case FC_HYPER: 3801 + case FC_DOUBLE: 3738 3802 *alignment = 8; 3739 3803 return 8; 3740 3804 3741 - case RPC_FC_INT3264: 3742 - case RPC_FC_UINT3264: 3805 + case FC_INT3264: 3806 + case FC_UINT3264: 3743 3807 assert( pointer_size ); 3744 3808 *alignment = pointer_size; 3745 3809 return pointer_size; 3746 3810 3747 - case RPC_FC_IGNORE: 3748 - case RPC_FC_BIND_PRIMITIVE: 3811 + case FC_IGNORE: 3812 + case FC_BIND_PRIMITIVE: 3749 3813 return 0; 3750 3814 3751 3815 default: ··· 3758 3822 case TGT_ENUM: 3759 3823 switch (get_enum_fc(type)) 3760 3824 { 3761 - case RPC_FC_ENUM32: 3825 + case FC_ENUM32: 3762 3826 *alignment = 4; 3763 3827 return 4; 3764 - case RPC_FC_ENUM16: 3828 + case FC_ENUM16: 3765 3829 *alignment = 4; 3766 3830 return 2; 3767 3831 } 3768 3832 break; 3769 3833 3770 3834 case TGT_STRUCT: 3771 - if (get_struct_fc(type) == RPC_FC_STRUCT) 3835 + if (get_struct_fc(type) == FC_STRUCT) 3772 3836 { 3773 3837 if (!type_struct_get_fields(type)) return 0; 3774 3838 return fields_memsize(type_struct_get_fields(type), alignment); ··· 3781 3845 const type_t *ref = type_pointer_get_ref(type); 3782 3846 if (is_string_type( attrs, ref )) break; 3783 3847 if (!(size = get_required_buffer_size_type( ref, name, NULL, FALSE, &align ))) break; 3784 - if (get_pointer_fc(type, attrs, toplevel_param) != RPC_FC_RP) 3848 + if (get_pointer_fc(type, attrs, toplevel_param) != FC_RP) 3785 3849 { 3786 3850 size += 4 + align; 3787 3851 align = 4; ··· 3791 3855 } 3792 3856 3793 3857 case TGT_ARRAY: 3794 - if (get_pointer_fc(type, attrs, toplevel_param) == RPC_FC_RP) 3858 + if (get_pointer_fc(type, attrs, toplevel_param) == FC_RP) 3795 3859 { 3796 3860 switch (get_array_fc(type)) 3797 3861 { 3798 - case RPC_FC_SMFARRAY: 3799 - case RPC_FC_LGFARRAY: 3862 + case FC_SMFARRAY: 3863 + case FC_LGFARRAY: 3800 3864 return type_array_get_dim(type) * 3801 3865 get_required_buffer_size_type(type_array_get_element(type), name, 3802 3866 NULL, FALSE, alignment); ··· 3938 4002 const type_t *ref = is_ptr(type) ? type_pointer_get_ref(type) : type; 3939 4003 switch (get_basic_fc(ref)) 3940 4004 { 3941 - case RPC_FC_BYTE: 3942 - case RPC_FC_CHAR: 3943 - case RPC_FC_SMALL: 3944 - case RPC_FC_USMALL: 4005 + case FC_BYTE: 4006 + case FC_CHAR: 4007 + case FC_SMALL: 4008 + case FC_USMALL: 3945 4009 alignment = 1; 3946 4010 break; 3947 4011 3948 - case RPC_FC_WCHAR: 3949 - case RPC_FC_USHORT: 3950 - case RPC_FC_SHORT: 4012 + case FC_WCHAR: 4013 + case FC_USHORT: 4014 + case FC_SHORT: 3951 4015 alignment = 2; 3952 4016 break; 3953 4017 3954 - case RPC_FC_ULONG: 3955 - case RPC_FC_LONG: 3956 - case RPC_FC_FLOAT: 3957 - case RPC_FC_ERROR_STATUS_T: 4018 + case FC_ULONG: 4019 + case FC_LONG: 4020 + case FC_FLOAT: 4021 + case FC_ERROR_STATUS_T: 3958 4022 /* pointer_size must be 4 if we got here in these two cases */ 3959 - case RPC_FC_INT3264: 3960 - case RPC_FC_UINT3264: 4023 + case FC_INT3264: 4024 + case FC_UINT3264: 3961 4025 alignment = 4; 3962 4026 break; 3963 4027 3964 - case RPC_FC_HYPER: 3965 - case RPC_FC_DOUBLE: 4028 + case FC_HYPER: 4029 + case FC_DOUBLE: 3966 4030 alignment = 8; 3967 4031 break; 3968 4032 3969 - case RPC_FC_IGNORE: 3970 - case RPC_FC_BIND_PRIMITIVE: 4033 + case FC_IGNORE: 4034 + case FC_BIND_PRIMITIVE: 3971 4035 /* no marshalling needed */ 3972 4036 return; 3973 4037 ··· 4201 4265 break; 4202 4266 case TGT_STRING: 4203 4267 if (phase == PHASE_FREE || pass == PASS_RETURN || 4204 - pointer_type != RPC_FC_RP) 4268 + pointer_type != FC_RP) 4205 4269 { 4206 4270 /* strings returned are assumed to be global and hence don't 4207 4271 * need freeing */ 4208 4272 if (is_declptr(type) && !(phase == PHASE_FREE && pass == PASS_RETURN)) 4209 4273 print_phase_function(file, indent, "Pointer", local_var_prefix, 4210 4274 phase, var, start_offset); 4211 - else if (pointer_type == RPC_FC_RP && phase == PHASE_FREE && 4275 + else if (pointer_type == FC_RP && phase == PHASE_FREE && 4212 4276 !in_attr && is_conformant_array(type)) 4213 4277 { 4214 4278 print_file(file, indent, "if (%s%s)\n", local_var_prefix, var->name); ··· 4250 4314 4251 4315 switch (tc) 4252 4316 { 4253 - case RPC_FC_SMFARRAY: 4254 - case RPC_FC_LGFARRAY: 4317 + case FC_SMFARRAY: 4318 + case FC_LGFARRAY: 4255 4319 array_type = "FixedArray"; 4256 4320 break; 4257 - case RPC_FC_SMVARRAY: 4258 - case RPC_FC_LGVARRAY: 4321 + case FC_SMVARRAY: 4322 + case FC_LGVARRAY: 4259 4323 array_type = "VaryingArray"; 4260 4324 break; 4261 - case RPC_FC_CARRAY: 4325 + case FC_CARRAY: 4262 4326 array_type = "ConformantArray"; 4263 4327 break; 4264 - case RPC_FC_CVARRAY: 4328 + case FC_CVARRAY: 4265 4329 array_type = "ConformantVaryingArray"; 4266 4330 break; 4267 - case RPC_FC_BOGUS_ARRAY: 4331 + case FC_BOGUS_ARRAY: 4268 4332 array_type = "ComplexArray"; 4269 4333 break; 4270 4334 } 4271 4335 4272 - if (pointer_type != RPC_FC_RP) array_type = "Pointer"; 4336 + if (pointer_type != FC_RP) array_type = "Pointer"; 4273 4337 4274 - if (phase == PHASE_FREE && pointer_type == RPC_FC_RP) 4338 + if (phase == PHASE_FREE && pointer_type == FC_RP) 4275 4339 { 4276 4340 /* these are all unmarshalled by allocating memory */ 4277 - if (tc == RPC_FC_BOGUS_ARRAY || 4278 - tc == RPC_FC_CVARRAY || 4279 - ((tc == RPC_FC_SMVARRAY || tc == RPC_FC_LGVARRAY) && in_attr) || 4280 - (tc == RPC_FC_CARRAY && !in_attr)) 4341 + if (tc == FC_BOGUS_ARRAY || 4342 + tc == FC_CVARRAY || 4343 + ((tc == FC_SMVARRAY || tc == FC_LGVARRAY) && in_attr) || 4344 + (tc == FC_CARRAY && !in_attr)) 4281 4345 { 4282 4346 if (type_array_is_decl_as_ptr(type) && type->details.array.ptr_tfsoff) 4283 4347 { ··· 4328 4392 case TGT_STRUCT: 4329 4393 switch (get_struct_fc(type)) 4330 4394 { 4331 - case RPC_FC_STRUCT: 4395 + case FC_STRUCT: 4332 4396 if (phase == PHASE_MARSHAL || phase == PHASE_UNMARSHAL) 4333 4397 print_phase_function(file, indent, "SimpleStruct", local_var_prefix, phase, var, start_offset); 4334 4398 break; 4335 - case RPC_FC_PSTRUCT: 4399 + case FC_PSTRUCT: 4336 4400 print_phase_function(file, indent, "SimpleStruct", local_var_prefix, phase, var, start_offset); 4337 4401 break; 4338 - case RPC_FC_CSTRUCT: 4339 - case RPC_FC_CPSTRUCT: 4402 + case FC_CSTRUCT: 4403 + case FC_CPSTRUCT: 4340 4404 print_phase_function(file, indent, "ConformantStruct", local_var_prefix, phase, var, start_offset); 4341 4405 break; 4342 - case RPC_FC_CVSTRUCT: 4406 + case FC_CVSTRUCT: 4343 4407 print_phase_function(file, indent, "ConformantVaryingStruct", local_var_prefix, phase, var, start_offset); 4344 4408 break; 4345 - case RPC_FC_BOGUS_STRUCT: 4409 + case FC_BOGUS_STRUCT: 4346 4410 print_phase_function(file, indent, "ComplexStruct", local_var_prefix, phase, var, start_offset); 4347 4411 break; 4348 4412 default: ··· 4365 4429 case TGT_POINTER: 4366 4430 { 4367 4431 const type_t *ref = type_pointer_get_ref(type); 4368 - if (pointer_type == RPC_FC_RP) switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES)) 4432 + if (pointer_type == FC_RP) switch (typegen_detect_type(ref, NULL, TDT_ALL_TYPES)) 4369 4433 { 4370 4434 case TGT_BASIC: 4371 4435 print_phase_basetype(file, indent, local_var_prefix, phase, pass, var, var->name); ··· 4380 4444 case TGT_STRUCT: 4381 4445 switch (get_struct_fc(ref)) 4382 4446 { 4383 - case RPC_FC_STRUCT: 4447 + case FC_STRUCT: 4384 4448 /* simple structs have known sizes, so don't need a sizing 4385 4449 * pass and don't have any memory to free and so don't 4386 4450 * need a freeing pass */ ··· 4394 4458 indent--; 4395 4459 } 4396 4460 break; 4397 - case RPC_FC_PSTRUCT: 4461 + case FC_PSTRUCT: 4398 4462 type_str = "SimpleStruct"; 4399 4463 break; 4400 - case RPC_FC_CSTRUCT: 4401 - case RPC_FC_CPSTRUCT: 4464 + case FC_CSTRUCT: 4465 + case FC_CPSTRUCT: 4402 4466 type_str = "ConformantStruct"; 4403 4467 break; 4404 - case RPC_FC_CVSTRUCT: 4468 + case FC_CVSTRUCT: 4405 4469 type_str = "ConformantVaryingStruct"; 4406 4470 break; 4407 - case RPC_FC_BOGUS_STRUCT: 4471 + case FC_BOGUS_STRUCT: 4408 4472 type_str = "ComplexStruct"; 4409 4473 break; 4410 4474 default: ··· 4505 4569 return offset; 4506 4570 } 4507 4571 4508 - unsigned int get_size_procformatstring(const statement_list_t *stmts, type_pred_t pred) 4572 + static void get_size_procformatstring_iface(type_t *iface, FILE *file, int indent, unsigned int *size) 4509 4573 { 4510 4574 const statement_t *stmt; 4511 - unsigned int size = 1; 4512 - 4513 - if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry ) 4575 + STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) ) 4514 4576 { 4515 - const type_t *iface; 4516 - const statement_t *stmt_func; 4517 - 4518 - if (stmt->type != STMT_TYPE || type_get_type(stmt->u.type) != TYPE_INTERFACE) 4519 - continue; 4520 - 4521 - iface = stmt->u.type; 4522 - if (!pred(iface)) 4523 - continue; 4524 - 4525 - STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(iface) ) 4526 - { 4527 - const var_t *func = stmt_func->u.var; 4528 - if (!is_local(func->attrs)) 4529 - size += get_size_procformatstring_func( iface, func ); 4530 - } 4577 + const var_t *func = stmt->u.var; 4578 + if (!is_local(func->attrs)) 4579 + *size += get_size_procformatstring_func( iface, func ); 4531 4580 } 4581 + } 4582 + 4583 + unsigned int get_size_procformatstring(const statement_list_t *stmts, type_pred_t pred) 4584 + { 4585 + unsigned int size = 1; 4586 + for_each_iface(stmts, get_size_procformatstring_iface, pred, NULL, 0, &size); 4532 4587 return size; 4533 4588 } 4534 4589
+1
sdk/tools/widl/typegen.h
··· 100 100 unsigned char get_pointer_fc(const type_t *type, const attr_list_t *attrs, int toplevel_param); 101 101 unsigned char get_struct_fc(const type_t *type); 102 102 enum typegen_type typegen_detect_type(const type_t *type, const attr_list_t *attrs, unsigned int flags); 103 + unsigned int type_memsize_and_alignment(const type_t *t, unsigned int *align);
+13 -7
sdk/tools/widl/typelib.c
··· 48 48 #include "typelib_struct.h" 49 49 #include "typetree.h" 50 50 51 + #ifdef __REACTOS__ 51 52 static typelib_t *typelib; 53 + #endif 52 54 53 55 /* List of oleauto types that should be recognized by name. 54 56 * (most of) these seem to be intrinsic types in mktyplib. ··· 161 163 else 162 164 return VT_INT; 163 165 case TYPE_BASIC_INT32: 166 + case TYPE_BASIC_LONG: 164 167 case TYPE_BASIC_ERROR_STATUS_T: 165 168 if (type_basic_get_sign(t) > 0) 166 169 return VT_UI4; ··· 173 176 else 174 177 return VT_I8; 175 178 case TYPE_BASIC_INT3264: 176 - if (typelib_kind == SYS_WIN64) 179 + if (pointer_size == 8) 177 180 { 178 181 if (type_basic_get_sign(t) > 0) 179 182 return VT_UI8; ··· 204 207 { 205 208 if (match(type_array_get_element(t)->name, "SAFEARRAY")) 206 209 return VT_SAFEARRAY; 210 + return VT_PTR; 207 211 } 208 212 else 209 - error("get_type_vt: array types not supported\n"); 210 - return VT_PTR; 213 + return VT_CARRAY; 211 214 212 215 case TYPE_INTERFACE: 213 216 if(match(t->name, "IUnknown")) ··· 243 246 return 0; 244 247 } 245 248 249 + #ifdef __REACTOS__ 246 250 void start_typelib(typelib_t *typelib_type) 247 251 { 248 252 if (!do_typelib) return; ··· 253 257 { 254 258 if (!typelib) return; 255 259 256 - if (do_old_typelib) 257 - create_sltg_typelib(typelib); 258 - else 259 - create_msft_typelib(typelib); 260 + create_msft_typelib(typelib); 260 261 } 262 + #endif 261 263 262 264 static void tlb_read(int fd, void *buf, int count) 263 265 { ··· 383 385 close(fd); 384 386 } 385 387 388 + #ifdef __REACTOS__ 386 389 void add_importlib(const char *name) 390 + #else 391 + void add_importlib(const char *name, typelib_t *typelib) 392 + #endif 387 393 { 388 394 importlib_t *importlib; 389 395
+4
sdk/tools/widl/typelib.h
··· 21 21 #ifndef __WIDL_TYPELIB_H 22 22 #define __WIDL_TYPELIB_H 23 23 24 + #ifdef __REACTOS__ 24 25 extern void start_typelib(typelib_t *typelib_type); 25 26 extern void end_typelib(void); 26 27 extern void add_importlib(const char *name); 28 + #else 29 + extern void add_importlib(const char *name, typelib_t *typelib); 30 + #endif 27 31 28 32 /* Copied from wtypes.h. Not included directly because that would create a 29 33 * circular dependency (after all, wtypes.h is generated by widl...) */
+15 -2
sdk/tools/widl/typetree.c
··· 377 377 case TYPE_BASIC_INT64: 378 378 case TYPE_BASIC_INT: 379 379 case TYPE_BASIC_INT3264: 380 + case TYPE_BASIC_LONG: 380 381 case TYPE_BASIC_CHAR: 381 382 case TYPE_BASIC_HYPER: 382 383 case TYPE_BASIC_BYTE: ··· 442 443 iface->details.iface->disp_methods = NULL; 443 444 iface->details.iface->stmts = stmts; 444 445 iface->details.iface->inherit = inherit; 446 + iface->details.iface->disp_inherit = NULL; 447 + iface->details.iface->async_iface = NULL; 445 448 iface->defined = TRUE; 446 449 compute_method_indexes(iface); 447 450 } ··· 454 457 iface->details.iface->stmts = NULL; 455 458 iface->details.iface->inherit = find_type("IDispatch", NULL, 0); 456 459 if (!iface->details.iface->inherit) error_loc("IDispatch is undefined\n"); 460 + iface->details.iface->disp_inherit = NULL; 461 + iface->details.iface->async_iface = NULL; 457 462 iface->defined = TRUE; 458 463 compute_method_indexes(iface); 459 464 } 460 465 461 466 void type_dispinterface_define_from_iface(type_t *dispiface, type_t *iface) 462 467 { 463 - type_dispinterface_define(dispiface, iface->details.iface->disp_props, 464 - iface->details.iface->disp_methods); 468 + dispiface->details.iface = xmalloc(sizeof(*dispiface->details.iface)); 469 + dispiface->details.iface->disp_props = NULL; 470 + dispiface->details.iface->disp_methods = NULL; 471 + dispiface->details.iface->stmts = NULL; 472 + dispiface->details.iface->inherit = find_type("IDispatch", NULL, 0); 473 + if (!dispiface->details.iface->inherit) error_loc("IDispatch is undefined\n"); 474 + dispiface->details.iface->disp_inherit = iface; 475 + dispiface->details.iface->async_iface = NULL; 476 + dispiface->defined = TRUE; 477 + compute_method_indexes(dispiface); 465 478 } 466 479 467 480 void type_module_define(type_t *module, statement_list_t *stmts)
+7
sdk/tools/widl/typetree.h
··· 176 176 return type->details.iface->disp_methods; 177 177 } 178 178 179 + static inline type_t *type_dispiface_get_inherit(const type_t *type) 180 + { 181 + type = type_get_real_type(type); 182 + assert(type_get_type(type) == TYPE_INTERFACE); 183 + return type->details.iface->disp_inherit; 184 + } 185 + 179 186 static inline int type_is_defined(const type_t *type) 180 187 { 181 188 return type->defined;
+87 -36
sdk/tools/widl/widl.c
··· 43 43 #include "wine/wpp.h" 44 44 #include "header.h" 45 45 46 - /* future options to reserve characters for: */ 47 - /* A = ACF input filename */ 48 - /* J = do not search standard include path */ 49 - /* w = select win16/win32 output (?) */ 50 - 51 46 static const char usage[] = 52 47 "Usage: widl [options...] infile.idl\n" 53 48 " or: widl [options...] --dlldata-only name1 [name2...]\n" 49 + " --acf=file Use ACF file\n" 54 50 " -app_config Ignored, present for midl compatibility\n" 55 51 " -b arch Set the target architecture\n" 56 52 " -c Generate client stub\n" ··· 62 58 " -H file Name of header file (default is infile.h)\n" 63 59 " -I path Set include search dir to path (multiple -I allowed)\n" 64 60 " --local-stubs=file Write empty stubs for call_as/local methods to file\n" 65 - " -m32, -m64 Set the kind of typelib to build (Win32 or Win64)\n" 61 + " -m32, -m64 Set the target architecture (Win32 or Win64)\n" 66 62 " -N Do not preprocess input\n" 67 63 " --oldnames Use old naming conventions\n" 68 64 " --oldtlb Use old typelib (SLTG) format\n" ··· 73 69 " --prefix-client=p Prefix names of client stubs with 'p'\n" 74 70 " --prefix-server=p Prefix names of server functions with 'p'\n" 75 71 " -r Generate registration script\n" 72 + " -robust Ignored, present for midl compatibility\n" 76 73 " --winrt Enable Windows Runtime mode\n" 77 74 " --ns_prefix Prefix namespaces with ABI namespace\n" 78 75 " -s Generate server stub\n" ··· 80 77 " -u Generate interface identifiers file\n" 81 78 " -V Print version and exit\n" 82 79 " -W Enable pedantic warnings\n" 83 - " --win32 Only generate 32-bit code\n" 84 - " --win64 Only generate 64-bit code\n" 80 + " --win32, --win64 Set the target architecture (Win32 or Win64)\n" 85 81 " --win32-align n Set win32 structure alignment to 'n'\n" 86 82 " --win64-align n Set win64 structure alignment to 'n'\n" 87 83 "Debug level 'n' is a bitmask with following meaning:\n" ··· 96 92 static const char version_string[] = "Wine IDL Compiler version " PACKAGE_VERSION "\n" 97 93 "Copyright 2002 Ove Kaaven\n"; 98 94 95 + #ifdef __i386__ 96 + enum target_cpu target_cpu = CPU_x86; 97 + #elif defined(__x86_64__) 98 + enum target_cpu target_cpu = CPU_x86_64; 99 + #elif defined(__powerpc__) 100 + enum target_cpu target_cpu = CPU_POWERPC; 101 + #elif defined(__arm__) 102 + enum target_cpu target_cpu = CPU_ARM; 103 + #elif defined(__aarch64__) 104 + enum target_cpu target_cpu = CPU_ARM64; 105 + #else 106 + #error Unsupported CPU 107 + #endif 108 + 99 109 int debuglevel = DEBUGLEVEL_NONE; 100 110 int parser_debug, yy_flex_debug; 101 111 ··· 113 123 int do_dlldata = 0; 114 124 static int no_preprocess = 0; 115 125 int old_names = 0; 116 - int do_win32 = 1; 117 - int do_win64 = 1; 118 126 int win32_packing = 8; 119 127 int win64_packing = 8; 120 128 int winrt_mode = 0; ··· 123 131 124 132 char *input_name; 125 133 char *input_idl_name; 134 + char *acf_name; 126 135 char *header_name; 127 136 char *local_stubs_name; 128 137 char *header_token; ··· 146 155 static FILE *idfile; 147 156 148 157 unsigned int pointer_size = 0; 149 - syskind_t typelib_kind = sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32; 150 158 151 159 time_t now; 152 160 153 161 enum { 154 162 OLDNAMES_OPTION = CHAR_MAX + 1, 163 + ACF_OPTION, 164 + APP_CONFIG_OPTION, 155 165 DLLDATA_OPTION, 156 166 DLLDATA_ONLY_OPTION, 157 167 LOCAL_STUBS_OPTION, 168 + OLD_TYPELIB_OPTION, 158 169 PREFIX_ALL_OPTION, 159 170 PREFIX_CLIENT_OPTION, 160 171 PREFIX_SERVER_OPTION, 161 172 PRINT_HELP, 162 173 RT_NS_PREFIX, 163 174 RT_OPTION, 175 + ROBUST_OPTION, 164 176 WIN32_OPTION, 165 177 WIN64_OPTION, 166 178 WIN32_ALIGN_OPTION, 167 - WIN64_ALIGN_OPTION, 168 - APP_CONFIG_OPTION, 169 - OLD_TYPELIB_OPTION 179 + WIN64_ALIGN_OPTION 170 180 }; 171 181 172 182 static const char short_options[] = 173 183 "b:cC:d:D:EhH:I:m:No:O:pP:rsS:tT:uU:VW"; 174 184 static const struct option long_options[] = { 185 + { "acf", 1, NULL, ACF_OPTION }, 186 + { "app_config", 0, NULL, APP_CONFIG_OPTION }, 175 187 { "dlldata", 1, NULL, DLLDATA_OPTION }, 176 188 { "dlldata-only", 0, NULL, DLLDATA_ONLY_OPTION }, 177 189 { "help", 0, NULL, PRINT_HELP }, 178 190 { "local-stubs", 1, NULL, LOCAL_STUBS_OPTION }, 179 191 { "ns_prefix", 0, NULL, RT_NS_PREFIX }, 180 192 { "oldnames", 0, NULL, OLDNAMES_OPTION }, 193 + { "oldtlb", 0, NULL, OLD_TYPELIB_OPTION }, 181 194 { "output", 0, NULL, 'o' }, 182 195 { "prefix-all", 1, NULL, PREFIX_ALL_OPTION }, 183 196 { "prefix-client", 1, NULL, PREFIX_CLIENT_OPTION }, 184 197 { "prefix-server", 1, NULL, PREFIX_SERVER_OPTION }, 198 + { "robust", 0, NULL, ROBUST_OPTION }, 199 + { "target", 0, NULL, 'b' }, 185 200 { "winrt", 0, NULL, RT_OPTION }, 186 201 { "win32", 0, NULL, WIN32_OPTION }, 187 202 { "win64", 0, NULL, WIN64_OPTION }, 188 203 { "win32-align", 1, NULL, WIN32_ALIGN_OPTION }, 189 204 { "win64-align", 1, NULL, WIN64_ALIGN_OPTION }, 190 - { "app_config", 0, NULL, APP_CONFIG_OPTION }, 191 - { "oldtlb", 0, NULL, OLD_TYPELIB_OPTION }, 192 205 { NULL, 0, NULL, 0 } 193 206 }; 194 207 ··· 265 278 { 266 279 static const struct 267 280 { 268 - const char *name; 269 - syskind_t kind; 281 + const char *name; 282 + enum target_cpu cpu; 270 283 } cpu_names[] = 271 284 { 272 - { "i386", SYS_WIN32 }, 273 - { "i486", SYS_WIN32 }, 274 - { "i586", SYS_WIN32 }, 275 - { "i686", SYS_WIN32 }, 276 - { "i786", SYS_WIN32 }, 277 - { "amd64", SYS_WIN64 }, 278 - { "x86_64", SYS_WIN64 }, 279 - { "powerpc", SYS_WIN32 }, 280 - { "arm", SYS_WIN32 }, 281 - { "aarch64", SYS_WIN64 } 285 + { "i386", CPU_x86 }, 286 + { "i486", CPU_x86 }, 287 + { "i586", CPU_x86 }, 288 + { "i686", CPU_x86 }, 289 + { "i786", CPU_x86 }, 290 + { "amd64", CPU_x86_64 }, 291 + { "x86_64", CPU_x86_64 }, 292 + { "powerpc", CPU_POWERPC }, 293 + { "arm", CPU_ARM }, 294 + { "armv5", CPU_ARM }, 295 + { "armv6", CPU_ARM }, 296 + { "armv7", CPU_ARM }, 297 + { "arm64", CPU_ARM64 }, 298 + { "aarch64", CPU_ARM64 }, 282 299 }; 283 300 284 301 unsigned int i; ··· 292 309 { 293 310 if (!strcmp( cpu_names[i].name, spec )) 294 311 { 295 - typelib_kind = cpu_names[i].kind; 312 + target_cpu = cpu_names[i].cpu; 296 313 free( spec ); 297 314 return; 298 315 } ··· 487 504 uuid = get_attrp(type->attrs, ATTR_UUID); 488 505 write_id_guid(idfile, "IID", is_attr(type->attrs, ATTR_DISPINTERFACE) ? "DIID" : "IID", 489 506 type->name, uuid); 507 + if (type->details.iface->async_iface) 508 + { 509 + uuid = get_attrp(type->details.iface->async_iface->attrs, ATTR_UUID); 510 + write_id_guid(idfile, "IID", "IID", type->details.iface->async_iface->name, uuid); 511 + } 490 512 } 491 513 else if (type_get_type(type) == TYPE_COCLASS) 492 514 { ··· 537 559 fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n"); 538 560 fprintf(idfile, " DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8)\n\n"); 539 561 562 + fprintf(idfile, "#elif defined(__cplusplus)\n\n"); 563 + 564 + fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n"); 565 + fprintf(idfile, " EXTERN_C const type DECLSPEC_SELECTANY name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n"); 566 + 540 567 fprintf(idfile, "#else\n\n"); 541 568 542 569 fprintf(idfile, "#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \\\n"); 543 - fprintf(idfile, " const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n"); 570 + fprintf(idfile, " const type DECLSPEC_SELECTANY name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}\n\n"); 544 571 545 572 fprintf(idfile, "#endif\n\n"); 546 573 start_cplusplus_guard(idfile); ··· 605 632 use_abi_namespace = 1; 606 633 break; 607 634 case WIN32_OPTION: 608 - do_win32 = 1; 609 - do_win64 = 0; 635 + pointer_size = 4; 610 636 break; 611 637 case WIN64_OPTION: 612 - do_win32 = 0; 613 - do_win64 = 1; 638 + pointer_size = 8; 614 639 break; 615 640 case WIN32_ALIGN_OPTION: 616 641 win32_packing = strtol(optarg, NULL, 0); ··· 622 647 if(win64_packing != 2 && win64_packing != 4 && win64_packing != 8) 623 648 error("Packing must be one of 2, 4 or 8\n"); 624 649 break; 650 + case ACF_OPTION: 651 + acf_name = xstrdup(optarg); 652 + break; 625 653 case APP_CONFIG_OPTION: 626 654 /* widl does not distinguish between app_mode and default mode, 627 655 but we ignore this option for midl compatibility */ 656 + break; 657 + case ROBUST_OPTION: 658 + /* FIXME: Support robust option */ 628 659 break; 629 660 case 'b': 630 661 set_target( optarg ); ··· 657 688 wpp_add_include_path(optarg); 658 689 break; 659 690 case 'm': 660 - if (!strcmp( optarg, "32" )) typelib_kind = SYS_WIN32; 661 - else if (!strcmp( optarg, "64" )) typelib_kind = SYS_WIN64; 691 + if (!strcmp( optarg, "32" )) pointer_size = 4; 692 + else if (!strcmp( optarg, "64" )) pointer_size = 8; 662 693 break; 663 694 case 'N': 664 695 no_preprocess = 1; ··· 724 755 #ifdef DEFAULT_INCLUDE_DIR 725 756 wpp_add_include_path(DEFAULT_INCLUDE_DIR); 726 757 #endif 758 + 759 + switch (target_cpu) 760 + { 761 + case CPU_x86: 762 + if (pointer_size == 8) target_cpu = CPU_x86_64; 763 + else pointer_size = 4; 764 + break; 765 + case CPU_x86_64: 766 + if (pointer_size == 4) target_cpu = CPU_x86; 767 + else pointer_size = 8; 768 + break; 769 + case CPU_ARM64: 770 + if (pointer_size == 4) error( "Cannot build 32-bit code for this CPU\n" ); 771 + pointer_size = 8; 772 + break; 773 + default: 774 + if (pointer_size == 8) error( "Cannot build 64-bit code for this CPU\n" ); 775 + pointer_size = 4; 776 + break; 777 + } 727 778 728 779 /* if nothing specified, try to guess output type from the output file name */ 729 780 if (output_name && do_everything && !do_header && !do_typelib && !do_proxies &&
+11 -2
sdk/tools/widl/widl.h
··· 46 46 extern int do_idfile; 47 47 extern int do_dlldata; 48 48 extern int old_names; 49 - extern int do_win32; 50 - extern int do_win64; 51 49 extern int win32_packing; 52 50 extern int win64_packing; 53 51 extern int winrt_mode; ··· 55 53 56 54 extern char *input_name; 57 55 extern char *input_idl_name; 56 + extern char *acf_name; 58 57 extern char *header_name; 59 58 extern char *header_token; 60 59 extern char *local_stubs_name; ··· 76 75 extern int line_number; 77 76 extern int char_number; 78 77 78 + enum target_cpu 79 + { 80 + CPU_x86, CPU_x86_64, CPU_POWERPC, CPU_ARM, CPU_ARM64, CPU_LAST = CPU_ARM64 81 + }; 82 + 83 + extern enum target_cpu target_cpu; 84 + 79 85 enum stub_mode 80 86 { 81 87 MODE_Os, /* inline stubs */ ··· 90 96 extern void write_client(const statement_list_t *stmts); 91 97 extern void write_server(const statement_list_t *stmts); 92 98 extern void write_regscript(const statement_list_t *stmts); 99 + #ifndef __REACTOS__ 100 + extern void write_typelib_regscript(const statement_list_t *stmts); 101 + #endif 93 102 extern void output_typelib_regscript( const typelib_t *typelib ); 94 103 extern void write_local_stubs(const statement_list_t *stmts); 95 104 extern void write_dlldata(const statement_list_t *stmts);
+4 -4
sdk/tools/widl/widltypes.h
··· 24 24 #include <stdarg.h> 25 25 #include <assert.h> 26 26 #include "guiddef.h" 27 - #include "wine/rpcfc.h" 27 + #include "ndrtypes.h" 28 28 #include "wine/list.h" 29 29 30 30 #ifndef UUID_DEFINED ··· 59 59 typedef struct list var_list_t; 60 60 typedef struct list declarator_list_t; 61 61 typedef struct list ifref_list_t; 62 - typedef struct list array_dims_t; 63 62 typedef struct list user_type_list_t; 64 63 typedef struct list context_handle_list_t; 65 64 typedef struct list generic_handle_list_t; ··· 266 265 TYPE_BASIC_INT64, 267 266 TYPE_BASIC_INT, 268 267 TYPE_BASIC_INT3264, 268 + TYPE_BASIC_LONG, 269 269 TYPE_BASIC_CHAR, 270 270 TYPE_BASIC_HYPER, 271 271 TYPE_BASIC_BYTE, ··· 343 343 var_list_t *disp_methods; 344 344 var_list_t *disp_props; 345 345 struct _type_t *inherit; 346 + struct _type_t *disp_inherit; 347 + struct _type_t *async_iface; 346 348 }; 347 349 348 350 struct module_details ··· 464 466 var_t *var; 465 467 type_t *type; 466 468 type_t *func_type; 467 - array_dims_t *array; 468 469 expr_t *bits; 469 470 470 471 /* parser-internal */ ··· 552 553 SYS_WIN64 553 554 } syskind_t; 554 555 555 - extern syskind_t typelib_kind; 556 556 extern user_type_list_t user_type_list; 557 557 extern context_handle_list_t context_handle_list; 558 558 extern generic_handle_list_t generic_handle_list;
+162 -184
sdk/tools/widl/write_msft.c
··· 57 57 #include "hash.h" 58 58 #include "typetree.h" 59 59 #include "parser.h" 60 + #include "typegen.h" 60 61 61 62 #ifdef __REACTOS__ 62 63 #define S_OK 0 ··· 791 792 int vt, /* [I] vt to encode */ 792 793 type_t *type, /* [I] type */ 793 794 int *encoded_type, /* [O] The encoded type description. */ 794 - int *width, /* [O] The width of the type, or NULL. */ 795 - int *alignment, /* [O] The alignment of the type, or NULL. */ 796 795 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */ 797 796 { 798 797 int default_type; ··· 805 804 chat("encode_type vt %d type %p\n", vt, type); 806 805 807 806 default_type = 0x80000000 | (vt << 16) | vt; 808 - if (!width) width = &scratch; 809 - if (!alignment) alignment = &scratch; 810 807 if (!decoded_size) decoded_size = &scratch; 811 808 812 809 *decoded_size = 0; ··· 815 812 case VT_I1: 816 813 case VT_UI1: 817 814 *encoded_type = default_type; 818 - *width = 1; 819 - *alignment = 1; 820 815 break; 821 816 822 817 case VT_INT: 823 818 *encoded_type = 0x80000000 | (VT_I4 << 16) | VT_INT; 824 - if ((typelib->typelib_header.varflags & 0x0f) == SYS_WIN16) { 825 - *width = 2; 826 - *alignment = 2; 827 - } else { 828 - *width = 4; 829 - *alignment = 4; 830 - } 831 819 break; 832 820 833 821 case VT_UINT: 834 822 *encoded_type = 0x80000000 | (VT_UI4 << 16) | VT_UINT; 835 - if ((typelib->typelib_header.varflags & 0x0f) == SYS_WIN16) { 836 - *width = 2; 837 - *alignment = 2; 838 - } else { 839 - *width = 4; 840 - *alignment = 4; 841 - } 842 823 break; 843 824 844 825 case VT_UI2: 845 826 case VT_I2: 846 827 case VT_BOOL: 847 828 *encoded_type = default_type; 848 - *width = 2; 849 - *alignment = 2; 850 829 break; 851 830 852 831 case VT_I4: ··· 855 834 case VT_ERROR: 856 835 case VT_HRESULT: 857 836 *encoded_type = default_type; 858 - *width = 4; 859 - *alignment = 4; 860 837 break; 861 838 862 839 case VT_R8: 863 840 case VT_I8: 864 841 case VT_UI8: 865 842 *encoded_type = default_type; 866 - *width = 8; 867 - *alignment = 8; 868 843 break; 869 844 870 845 case VT_CY: 871 846 case VT_DATE: 872 847 *encoded_type = default_type; 873 - *width = 8; 874 - *alignment = 8; 875 848 break; 876 849 877 850 case VT_DECIMAL: 878 851 *encoded_type = default_type; 879 - *width = 16; 880 - *alignment = 8; 881 852 break; 882 853 883 854 case VT_VOID: 884 855 *encoded_type = 0x80000000 | (VT_EMPTY << 16) | vt; 885 - *width = 0; 886 - *alignment = 1; 887 856 break; 888 857 889 858 case VT_UNKNOWN: 890 859 case VT_DISPATCH: 891 860 case VT_BSTR: 892 861 *encoded_type = default_type; 893 - *width = pointer_size; 894 - *alignment = 4; 895 862 break; 896 863 897 864 case VT_VARIANT: 898 865 *encoded_type = default_type; 899 - *width = 8 + 2 * pointer_size; 900 - *alignment = 8; 901 866 break; 902 867 903 868 case VT_LPSTR: 904 869 case VT_LPWSTR: 905 870 *encoded_type = 0xfffe0000 | vt; 906 - *width = pointer_size; 907 - *alignment = 4; 908 871 break; 909 872 910 873 case VT_PTR: ··· 920 883 next_vt = VT_VOID; 921 884 922 885 encode_type(typelib, next_vt, type_pointer_get_ref(type), 923 - &target_type, NULL, NULL, &child_size); 886 + &target_type, &child_size); 924 887 /* these types already have an implicit pointer, so we don't need to 925 888 * add another */ 926 889 if(next_vt == VT_DISPATCH || next_vt == VT_UNKNOWN) { 927 890 chat("encode_type: skipping ptr\n"); 928 891 *encoded_type = target_type; 929 - *width = pointer_size; 930 - *alignment = 4; 931 892 *decoded_size = child_size; 932 893 break; 933 894 } ··· 956 917 957 918 *encoded_type = typeoffset; 958 919 959 - *width = pointer_size; 960 - *alignment = 4; 961 920 *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size; 962 921 break; 963 922 } ··· 967 926 type_t *element_type = type_alias_get_aliasee(type_array_get_element(type)); 968 927 int next_vt = get_type_vt(element_type); 969 928 970 - encode_type(typelib, next_vt, type_alias_get_aliasee(type_array_get_element(type)), &target_type, NULL, NULL, &child_size); 929 + encode_type(typelib, next_vt, type_alias_get_aliasee(type_array_get_element(type)), 930 + &target_type, &child_size); 971 931 972 932 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) { 973 933 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset]; ··· 993 953 994 954 *encoded_type = typeoffset; 995 955 996 - *width = pointer_size; 997 - *alignment = 4; 998 956 *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size; 999 957 break; 1000 958 } 1001 959 1002 960 case VT_USERDEFINED: 1003 961 { 962 + importinfo_t *importinfo; 1004 963 int typeinfo_offset; 1005 964 1006 - /* typedef'd types without public attribute aren't included in the typelib */ 1007 - while (type->typelib_idx < 0 && type_is_alias(type) && !is_attr(type->attrs, ATTR_PUBLIC)) 1008 - type = type_alias_get_aliasee(type); 965 + if (type->typelib_idx > -1) 966 + { 967 + chat("encode_type: VT_USERDEFINED - found already defined type %s at %d\n", 968 + type->name, type->typelib_idx); 969 + typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx]; 970 + } 971 + else if ((importinfo = find_importinfo(typelib, type->name))) 972 + { 973 + chat("encode_type: VT_USERDEFINED - found imported type %s in %s\n", 974 + type->name, importinfo->importlib->name); 975 + alloc_importinfo(typelib, importinfo); 976 + typeinfo_offset = importinfo->offset | 0x1; 977 + } 978 + else 979 + { 980 + /* typedef'd types without public attribute aren't included in the typelib */ 981 + while (type_is_alias(type) && !is_attr(type->attrs, ATTR_PUBLIC)) 982 + type = type_alias_get_aliasee(type); 1009 983 1010 - chat("encode_type: VT_USERDEFINED - type %p name = %s real type %d idx %d\n", type, 1011 - type->name, type_get_type(type), type->typelib_idx); 984 + chat("encode_type: VT_USERDEFINED - adding new type %s, real type %d\n", 985 + type->name, type_get_type(type)); 1012 986 1013 - if(type->typelib_idx == -1) { 1014 - chat("encode_type: trying to ref not added type\n"); 1015 - switch (type_get_type(type)) { 987 + switch (type_get_type(type)) 988 + { 1016 989 case TYPE_STRUCT: 1017 990 add_structure_typeinfo(typelib, type); 1018 991 break; ··· 1032 1005 error("encode_type: VT_USERDEFINED - unhandled type %d\n", 1033 1006 type_get_type(type)); 1034 1007 } 1035 - } 1036 1008 1037 - typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx]; 1009 + typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx]; 1010 + } 1038 1011 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) { 1039 1012 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset]; 1040 1013 if ((typedata[0] == ((0x7fff << 16) | VT_USERDEFINED)) && (typedata[1] == typeinfo_offset)) break; ··· 1049 1022 } 1050 1023 1051 1024 *encoded_type = typeoffset; 1052 - *width = 0; 1053 - *alignment = 1; 1054 1025 break; 1055 1026 } 1056 1027 1057 1028 default: 1058 1029 error("encode_type: unrecognized type %d.\n", vt); 1059 1030 *encoded_type = default_type; 1060 - *width = 0; 1061 - *alignment = 1; 1062 1031 break; 1063 1032 } 1064 1033 ··· 1075 1044 type_t *type, /* [I] The type description to encode. */ 1076 1045 var_t *var, /* [I] The var to encode. */ 1077 1046 int *encoded_type, /* [O] The encoded type description. */ 1078 - int *width, /* [O] The width of the type, or NULL. */ 1079 - int *alignment, /* [O] The alignment of the type, or NULL. */ 1080 1047 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */ 1081 1048 { 1082 1049 int typeoffset; ··· 1086 1053 int vt; 1087 1054 int scratch; 1088 1055 1089 - if (!width) width = &scratch; 1090 - if (!alignment) alignment = &scratch; 1091 1056 if (!decoded_size) decoded_size = &scratch; 1092 1057 *decoded_size = 0; 1093 1058 ··· 1106 1071 ++num_dims; 1107 1072 1108 1073 chat("array with %d dimensions\n", num_dims); 1109 - encode_var(typelib, atype, var, &target_type, width, alignment, NULL); 1074 + encode_var(typelib, atype, var, &target_type, NULL); 1110 1075 arrayoffset = ctl2_alloc_segment(typelib, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(int), 0); 1111 1076 arraydata = (void *)&typelib->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset]; 1112 1077 ··· 1132 1097 typedata[1] = arrayoffset; 1133 1098 1134 1099 *encoded_type = typeoffset; 1135 - *width = *width * elements; 1136 1100 *decoded_size = 20 /*sizeof(ARRAYDESC)*/ + (num_dims - 1) * 8 /*sizeof(SAFEARRAYBOUND)*/; 1137 1101 return 0; 1138 1102 } ··· 1141 1105 if (vt == VT_PTR) { 1142 1106 type_t *ref = is_ptr(type) ? 1143 1107 type_pointer_get_ref(type) : type_array_get_element(type); 1144 - int skip_ptr = encode_var(typelib, ref, var, 1145 - &target_type, NULL, NULL, &child_size); 1108 + int skip_ptr = encode_var(typelib, ref, var, &target_type, &child_size); 1146 1109 1147 1110 if(skip_ptr == 2) { 1148 1111 chat("encode_var: skipping ptr\n"); 1149 1112 *encoded_type = target_type; 1150 1113 *decoded_size = child_size; 1151 - *width = pointer_size; 1152 - *alignment = 4; 1153 1114 return 0; 1154 1115 } 1155 1116 ··· 1163 1124 1164 1125 if (target_type & 0x80000000) { 1165 1126 mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF; 1166 - } else if (is_array(ref)) { 1127 + } else if (get_type_vt(ref) == VT_SAFEARRAY) { 1167 1128 type_t *element_type = type_alias_get_aliasee(type_array_get_element(ref)); 1168 1129 mix_field = get_type_vt(element_type) | VT_ARRAY | VT_BYREF; 1169 1130 } else { ··· 1180 1141 1181 1142 *encoded_type = typeoffset; 1182 1143 1183 - *width = pointer_size; 1184 - *alignment = 4; 1185 1144 *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size; 1186 1145 return 0; 1187 1146 } 1188 1147 1189 1148 dump_type(type); 1190 1149 1191 - encode_type(typelib, vt, type, encoded_type, width, alignment, decoded_size); 1150 + encode_type(typelib, vt, type, encoded_type, decoded_size); 1192 1151 /* these types already have an implicit pointer, so we don't need to 1193 1152 * add another */ 1194 1153 if(vt == VT_DISPATCH || vt == VT_UNKNOWN) return 2; ··· 1210 1169 return val; 1211 1170 } 1212 1171 1213 - static void write_value(msft_typelib_t* typelib, int *out, int vt, const void *value) 1172 + static void write_int_value(msft_typelib_t *typelib, int *out, int vt, int value) 1214 1173 { 1215 - switch(vt) { 1216 - case VT_I2: 1217 - case VT_I4: 1218 - case VT_R4: 1219 - case VT_BOOL: 1220 - case VT_I1: 1221 - case VT_UI1: 1222 - case VT_UI2: 1223 - case VT_UI4: 1224 - case VT_INT: 1225 - case VT_UINT: 1226 - case VT_HRESULT: 1227 - case VT_PTR: 1228 - case VT_UNKNOWN: 1229 - case VT_DISPATCH: 1230 - { 1231 - const unsigned int lv = get_ulong_val(*(const unsigned int *)value, vt); 1232 - if((lv & 0x3ffffff) == lv) { 1233 - *out = 0x80000000; 1234 - *out |= vt << 26; 1235 - *out |= lv; 1236 - } else { 1237 - int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, 8, 0); 1238 - *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt; 1239 - memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], value, 4); 1240 - *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6]) = 0x5757; 1241 - *out = offset; 1242 - } 1243 - return; 1244 - } 1245 - case VT_BSTR: 1246 - { 1247 - const char *s = (const char *) value; 1248 - int len = strlen(s), seg_len = (len + 6 + 3) & ~0x3; 1249 - int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, seg_len, 0); 1174 + const unsigned int lv = get_ulong_val(value, vt); 1175 + if ((lv & 0x3ffffff) == lv) { 1176 + *out = 0x80000000; 1177 + *out |= vt << 26; 1178 + *out |= lv; 1179 + } else { 1180 + int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, 8, 0); 1250 1181 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt; 1251 - memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], &len, sizeof(len)); 1252 - memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6], value, len); 1253 - len += 6; 1254 - while(len < seg_len) { 1255 - *((char *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+len]) = 0x57; 1256 - len++; 1257 - } 1182 + memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], &value, 4); 1183 + *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6]) = 0x5757; 1258 1184 *out = offset; 1185 + } 1186 + } 1187 + 1188 + static void write_string_value(msft_typelib_t *typelib, int *out, const char *value) 1189 + { 1190 + int len = strlen(value), seg_len = (len + 6 + 3) & ~0x3; 1191 + int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, seg_len, 0); 1192 + *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = VT_BSTR; 1193 + memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], &len, sizeof(len)); 1194 + memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6], value, len); 1195 + len += 6; 1196 + while(len < seg_len) { 1197 + *((char *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+len]) = 0x57; 1198 + len++; 1199 + } 1200 + *out = offset; 1201 + } 1202 + 1203 + static void write_default_value(msft_typelib_t *typelib, type_t *type, expr_t *expr, int *out) 1204 + { 1205 + int vt; 1206 + 1207 + if (expr->type == EXPR_STRLIT || expr->type == EXPR_WSTRLIT) { 1208 + if (get_type_vt(type) != VT_BSTR) 1209 + error("string default value applied to non-string type\n"); 1210 + chat("default value '%s'\n", expr->u.sval); 1211 + write_string_value(typelib, out, expr->u.sval); 1259 1212 return; 1260 - } 1213 + } 1261 1214 1262 - default: 1263 - warning("can't write value of type %d yet\n", vt); 1215 + if (type_get_type(type) == TYPE_ENUM) { 1216 + vt = VT_I4; 1217 + } else if (is_ptr(type)) { 1218 + vt = get_type_vt(type_pointer_get_ref(type)); 1219 + if (vt == VT_USERDEFINED) 1220 + vt = VT_I4; 1221 + if (expr->cval) 1222 + warning("non-null pointer default value\n"); 1223 + } else { 1224 + vt = get_type_vt(type); 1225 + switch(vt) { 1226 + case VT_I2: 1227 + case VT_I4: 1228 + case VT_R4: 1229 + case VT_BOOL: 1230 + case VT_I1: 1231 + case VT_UI1: 1232 + case VT_UI2: 1233 + case VT_UI4: 1234 + case VT_INT: 1235 + case VT_UINT: 1236 + case VT_HRESULT: 1237 + break; 1238 + default: 1239 + warning("can't write value of type %d yet\n", vt); 1240 + return; 1241 + } 1264 1242 } 1265 - return; 1243 + 1244 + write_int_value(typelib, out, vt, expr->cval); 1266 1245 } 1267 1246 1268 1247 static HRESULT set_custdata(msft_typelib_t *typelib, REFGUID guid, ··· 1280 1259 guidentry.next_hash = -1; 1281 1260 1282 1261 guidoffset = ctl2_alloc_guid(typelib, &guidentry); 1283 - write_value(typelib, &data_out, vt, value); 1262 + if(vt == VT_BSTR) 1263 + write_string_value(typelib, &data_out, value); 1264 + else 1265 + write_int_value(typelib, &data_out, vt, *(int*)value); 1284 1266 1285 1267 custoffset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATAGUID, 12, 0); 1286 1268 ··· 1291 1273 *offset = custoffset; 1292 1274 1293 1275 return S_OK; 1294 - } 1295 - 1296 - /* It's possible to have a default value for pointer arguments too. 1297 - In this case default value has a referenced type, e.g. 1298 - 'LONG*' argument gets VT_I4, 'DOUBLE*' - VT_R8. IUnknown* and IDispatch* 1299 - are recognised too and stored as VT_UNKNOWN and VT_DISPATCH. 1300 - But IUnknown/IDispatch arguments can only have default value of 0 1301 - (or expression that resolves to zero) while other pointers can have 1302 - any default value. */ 1303 - static int get_defaultvalue_vt(type_t *type) 1304 - { 1305 - int vt; 1306 - if (type_get_type(type) == TYPE_ENUM) 1307 - vt = VT_I4; 1308 - else 1309 - { 1310 - vt = get_type_vt(type); 1311 - if (vt == VT_PTR && is_ptr(type)) { 1312 - vt = get_type_vt(type_pointer_get_ref(type)); 1313 - /* The only acceptable value for pointers to non-basic types 1314 - is NULL, it's stored as VT_I4 for both 32 and 64 bit typelibs. */ 1315 - if (vt == VT_USERDEFINED) 1316 - vt = VT_I4; 1317 - } 1318 - } 1319 - 1320 - return vt; 1321 1276 } 1322 1277 1323 1278 static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) ··· 1500 1455 1501 1456 /* fill out the basic type information */ 1502 1457 typedata[0] = typedata_size | (index << 16); 1503 - encode_var(typeinfo->typelib, type_function_get_rettype(func->type), func, &typedata[1], NULL, NULL, &decoded_size); 1458 + encode_var(typeinfo->typelib, type_function_get_rettype(func->type), func, 1459 + &typedata[1], &decoded_size); 1504 1460 typedata[2] = funcflags; 1505 1461 typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft; 1506 1462 typedata[4] = (next_idx << 16) | (callconv << 8) | (invokekind << 3) | funckind; ··· 1537 1493 1538 1494 if(defaultdata) *defaultdata = -1; 1539 1495 1540 - encode_var(typeinfo->typelib, arg->type, arg, paramdata, NULL, NULL, &decoded_size); 1496 + encode_var(typeinfo->typelib, arg->type, arg, paramdata, &decoded_size); 1541 1497 if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) { 1542 1498 switch(attr->type) { 1543 1499 case ATTR_DEFAULTVALUE: 1544 1500 { 1545 - int vt; 1546 - expr_t *expr = (expr_t *)attr->u.pval; 1547 - vt = get_defaultvalue_vt(arg->type); 1548 1501 paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */ 1549 - if (expr->type == EXPR_STRLIT || expr->type == EXPR_WSTRLIT) 1550 - { 1551 - if (vt != VT_BSTR) error("string default value applied to non-string type\n"); 1552 - chat("default value '%s'\n", expr->u.sval); 1553 - write_value(typeinfo->typelib, defaultdata, vt, expr->u.sval); 1554 - } 1555 - else 1556 - { 1557 - chat("default value %d\n", expr->cval); 1558 - write_value(typeinfo->typelib, defaultdata, vt, &expr->cval); 1559 - } 1502 + write_default_value(typeinfo->typelib, arg->type, (expr_t *)attr->u.pval, defaultdata); 1560 1503 break; 1561 1504 } 1562 1505 case ATTR_IN: ··· 1663 1606 int offset, id; 1664 1607 unsigned int typedata_size; 1665 1608 INT *typedata; 1666 - int var_datawidth; 1667 - int var_alignment; 1609 + unsigned int var_datawidth, var_alignment = 0; 1668 1610 int var_type_size, var_kind = 0 /* VAR_PERINSTANCE */; 1669 1611 int alignment; 1670 1612 int varflags = 0; ··· 1766 1708 typeinfo->var_offsets[var_num] = offset; 1767 1709 1768 1710 /* figure out type widths and whatnot */ 1769 - encode_var(typeinfo->typelib, var->type, var, &typedata[1], &var_datawidth, 1770 - &var_alignment, &var_type_size); 1711 + var_datawidth = type_memsize_and_alignment(var->type, &var_alignment); 1712 + encode_var(typeinfo->typelib, var->type, var, &typedata[1], &var_type_size); 1771 1713 1772 1714 /* pad out starting position to data width */ 1773 1715 typeinfo->datawidth += var_alignment - 1; ··· 1775 1717 1776 1718 switch(typeinfo->typekind) { 1777 1719 case TKIND_ENUM: 1778 - write_value(typeinfo->typelib, &typedata[4], VT_I4, &var->eval->cval); 1720 + write_int_value(typeinfo->typelib, &typedata[4], VT_I4, var->eval->cval); 1779 1721 var_kind = 2; /* VAR_CONST */ 1780 1722 var_type_size += 16; /* sizeof(VARIANT) */ 1781 1723 typeinfo->datawidth = var_datawidth; ··· 1791 1733 case TKIND_DISPATCH: 1792 1734 var_kind = 3; /* VAR_DISPATCH */ 1793 1735 typeinfo->datawidth = pointer_size; 1794 - var_alignment = 4; 1795 1736 break; 1796 1737 default: 1797 1738 error("add_var_desc: unhandled type kind %d\n", typeinfo->typekind); ··· 2038 1979 2039 1980 static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinterface) 2040 1981 { 1982 + int num_parents = 0, num_funcs = 0; 1983 + importinfo_t *importinfo = NULL; 1984 + const statement_t *stmt_func; 1985 + type_t *inherit, *ref; 2041 1986 int idx = 0; 2042 1987 var_t *func; 2043 1988 var_t *var; ··· 2046 1991 if (-1 < dispinterface->typelib_idx) 2047 1992 return; 2048 1993 1994 + inherit = type_dispiface_get_inherit(dispinterface); 1995 + 1996 + if (inherit) 1997 + { 1998 + importinfo = find_importinfo(typelib, inherit->name); 1999 + 2000 + if (!importinfo && type_iface_get_inherit(inherit) && inherit->typelib_idx == -1) 2001 + add_interface_typeinfo(typelib, inherit); 2002 + } 2003 + 2004 + /* check typelib_idx again, it could have been added while resolving the parent interface */ 2005 + if (-1 < dispinterface->typelib_idx) 2006 + return; 2007 + 2049 2008 dispinterface->typelib_idx = typelib->typelib_header.nrtypeinfos; 2050 2009 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_DISPATCH, dispinterface->name, 2051 2010 dispinterface->attrs); 2052 2011 2053 2012 msft_typeinfo->typeinfo->size = pointer_size; 2054 - msft_typeinfo->typeinfo->typekind |= 0x2100; 2013 + msft_typeinfo->typeinfo->typekind |= pointer_size << 11 | pointer_size << 6; 2055 2014 2056 2015 msft_typeinfo->typeinfo->flags |= 0x1000; /* TYPEFLAG_FDISPATCHABLE */ 2057 2016 add_dispatch(typelib); 2058 - msft_typeinfo->typeinfo->cImplTypes = 1; 2017 + 2018 + if (inherit) 2019 + { 2020 + add_impl_type(msft_typeinfo, inherit, importinfo); 2021 + msft_typeinfo->typeinfo->typekind |= 0x10; 2022 + } 2023 + 2024 + /* count the number of inherited interfaces and non-local functions */ 2025 + for (ref = inherit; ref; ref = type_iface_get_inherit(ref)) 2026 + { 2027 + num_parents++; 2028 + STATEMENTS_FOR_EACH_FUNC( stmt_func, type_iface_get_stmts(ref) ) 2029 + { 2030 + var_t *func = stmt_func->u.var; 2031 + if (!is_local(func->attrs)) num_funcs++; 2032 + } 2033 + } 2034 + msft_typeinfo->typeinfo->datatype2 = num_funcs << 16 | num_parents; 2035 + msft_typeinfo->typeinfo->cbSizeVft = num_funcs * pointer_size; 2036 + 2037 + msft_typeinfo->typeinfo->cImplTypes = 1; /* IDispatch */ 2059 2038 2060 2039 /* count the no of methods, as the variable indices come after the funcs */ 2061 2040 if (dispinterface->details.iface->disp_methods) ··· 2120 2099 interface->typelib_idx = typelib->typelib_header.nrtypeinfos; 2121 2100 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_INTERFACE, interface->name, interface->attrs); 2122 2101 msft_typeinfo->typeinfo->size = pointer_size; 2123 - msft_typeinfo->typeinfo->typekind |= 0x2200; 2102 + msft_typeinfo->typeinfo->typekind |= 0x0200; 2103 + msft_typeinfo->typeinfo->typekind |= pointer_size << 11; 2124 2104 2125 2105 for (derived = inherit; derived; derived = type_iface_get_inherit(derived)) 2126 2106 if (derived->name && !strcmp(derived->name, "IDispatch")) 2127 2107 msft_typeinfo->typeinfo->flags |= 0x1000; /* TYPEFLAG_FDISPATCHABLE */ 2128 - 2129 - /* can't be dual if it doesn't derive from IDispatch */ 2130 - if (!(msft_typeinfo->typeinfo->flags & 0x1000)) /* TYPEFLAG_FDISPATCHABLE */ 2131 - msft_typeinfo->typeinfo->flags &= ~0x40; /* TYPEFLAG_FDUAL */ 2132 2108 2133 2109 if(type_iface_get_inherit(interface)) 2134 2110 add_impl_type(msft_typeinfo, type_iface_get_inherit(interface), ··· 2209 2185 static void add_typedef_typeinfo(msft_typelib_t *typelib, type_t *tdef) 2210 2186 { 2211 2187 msft_typeinfo_t *msft_typeinfo = NULL; 2212 - int alignment, datatype1, datatype2, size, duplicate = 0; 2188 + int datatype1, datatype2, duplicate = 0; 2189 + unsigned int size, alignment = 0; 2213 2190 type_t *type; 2214 2191 2215 2192 if (-1 < tdef->typelib_idx) ··· 2225 2202 else 2226 2203 duplicate = 1; 2227 2204 2228 - encode_type(typelib, get_type_vt(type), type, 2229 - &datatype1, &size, &alignment, &datatype2); 2205 + encode_type(typelib, get_type_vt(type), type, &datatype1, &datatype2); 2206 + size = type_memsize_and_alignment(type, &alignment); 2230 2207 2231 2208 if (msft_typeinfo) 2232 2209 { ··· 2367 2344 break; 2368 2345 case TYPE_BASIC: 2369 2346 case TYPE_POINTER: 2347 + case TYPE_ARRAY: 2370 2348 break; 2371 2349 default: 2372 2350 error("add_entry: unhandled type 0x%x for %s\n", ··· 2669 2647 sprintf( typelib_id, "#%d", expr->cval ); 2670 2648 add_output_to_resources( "TYPELIB", typelib_id ); 2671 2649 output_typelib_regscript( typelib->typelib ); 2650 + #ifdef __REACTOS__ 2672 2651 flush_output_resources( typelib_name ); 2652 + #endif 2673 2653 } 2674 2654 else flush_output_buffer( typelib_name ); 2675 2655 } ··· 2687 2667 GUID midl_info_guid = {0xde77ba65,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}}; 2688 2668 char info_string[128]; 2689 2669 2690 - pointer_size = (typelib_kind == SYS_WIN64) ? 8 : 4; 2691 - 2692 2670 msft = xmalloc(sizeof(*msft)); 2693 2671 memset(msft, 0, sizeof(*msft)); 2694 2672 msft->typelib = typelib; ··· 2696 2674 ctl2_init_header(msft); 2697 2675 ctl2_init_segdir(msft); 2698 2676 2699 - msft->typelib_header.varflags |= typelib_kind; 2677 + msft->typelib_header.varflags |= (pointer_size == 8) ? SYS_WIN64 : SYS_WIN32; 2700 2678 2701 2679 /* 2702 2680 * The following two calls return an offset or -1 if out of memory. We
+2 -5
sdk/tools/widl/write_sltg.c
··· 329 329 sltg->library.name = add_name(sltg, sltg->typelib->name); 330 330 sltg->library.helpstring = NULL; 331 331 sltg->library.helpcontext = 0; 332 - sltg->library.syskind = typelib_kind; 332 + sltg->library.syskind = (pointer_size == 8) ? SYS_WIN64 : SYS_WIN32; 333 333 sltg->library.lcid = 0x0409; 334 334 sltg->library.libflags = 0; 335 335 sltg->library.version = 0; ··· 719 719 720 720 case VT_INT: 721 721 case VT_UINT: 722 - return typelib_kind == SYS_WIN16 ? 2 : 4; 722 + return /* typelib_kind == SYS_WIN16 ? 2 : */ 4; 723 723 724 724 case VT_UI2: 725 725 case VT_I2: ··· 1824 1824 sprintf(typelib_id, "#%d", expr->cval); 1825 1825 add_output_to_resources("TYPELIB", typelib_id); 1826 1826 output_typelib_regscript(typelib->typelib); 1827 - flush_output_resources(typelib_name); 1828 1827 } 1829 1828 else flush_output_buffer(typelib_name); 1830 1829 } ··· 1835 1834 const statement_t *stmt; 1836 1835 void *library_block; 1837 1836 int library_block_size, library_block_index; 1838 - 1839 - pointer_size = (typelib_kind == SYS_WIN64) ? 8 : 4; 1840 1837 1841 1838 sltg.typelib = typelib; 1842 1839 sltg.typeinfo_count = 0;