diff options
Diffstat (limited to 'gcc/java/parse.c')
| -rw-r--r-- | gcc/java/parse.c | 10888 |
1 files changed, 7131 insertions, 3757 deletions
diff --git a/gcc/java/parse.c b/gcc/java/parse.c index 224ae38c7f6..bdce35974c0 100644 --- a/gcc/java/parse.c +++ b/gcc/java/parse.c @@ -1,5 +1,5 @@ -/* A Bison parser, made from /nfs/hoser/beer/java/egcs/gcc/java/parse.y +/* A Bison parser, made from ./parse.y by GNU Bison version 1.25 */ @@ -120,28 +120,203 @@ #define BOOL_LIT_TK 363 #define NULL_TK 364 -#line 49 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <dirent.h> -#ifdef __STDC__ -#include <stdarg.h> -#else -#include <varargs.h> -#endif +#line 48 "./parse.y" #include "config.h" +#include "system.h" +#include <dirent.h> #include "tree.h" #include "rtl.h" #include "obstack.h" +#include "toplev.h" #include "flags.h" #include "java-tree.h" #include "jcf.h" #include "lex.h" #include "parse.h" #include "zipfile.h" +#include "convert.h" +#include "buffer.h" +#include "xref.h" + +#ifndef DIR_SEPARATOR +#define DIR_SEPARATOR '/' +#endif + +/* Local function prototypes */ +static char *java_accstring_lookup PROTO ((int)); +static void classitf_redefinition_error PROTO ((char *,tree, tree, tree)); +static void variable_redefinition_error PROTO ((tree, tree, tree, int)); +static void check_modifiers PROTO ((char *, int, int)); +static tree create_class PROTO ((int, tree, tree, tree)); +static tree create_interface PROTO ((int, tree, tree)); +static tree find_field PROTO ((tree, tree)); +static tree lookup_field_wrapper PROTO ((tree, tree)); +static int duplicate_declaration_error_p PROTO ((tree, tree, tree)); +static void register_fields PROTO ((int, tree, tree)); +static tree parser_qualified_classname PROTO ((tree)); +static int parser_check_super PROTO ((tree, tree, tree)); +static int parser_check_super_interface PROTO ((tree, tree, tree)); +static void check_modifiers_consistency PROTO ((int)); +static tree lookup_cl PROTO ((tree)); +static tree lookup_java_method2 PROTO ((tree, tree, int)); +static tree method_header PROTO ((int, tree, tree, tree)); +static void fix_method_argument_names PROTO ((tree ,tree)); +static tree method_declarator PROTO ((tree, tree)); +static void parse_warning_context PVPROTO ((tree cl, const char *msg, ...)) + ATTRIBUTE_PRINTF_2; +static void issue_warning_error_from_context PROTO ((tree, const char *msg, va_list)); +static tree parse_jdk1_1_error PROTO ((char *)); +static void complete_class_report_errors PROTO ((jdep *)); +static int process_imports PROTO ((void)); +static void read_import_dir PROTO ((tree)); +static int find_in_imports_on_demand PROTO ((tree)); +static int find_in_imports PROTO ((tree)); +static int check_pkg_class_access PROTO ((tree, tree)); +static tree resolve_package PROTO ((tree, tree *)); +static tree lookup_package_type PROTO ((char *, int)); +static tree resolve_class PROTO ((tree, tree, tree)); +static void declare_local_variables PROTO ((int, tree, tree)); +static void source_start_java_method PROTO ((tree)); +static void source_end_java_method PROTO ((void)); +static void expand_start_java_method PROTO ((tree)); +static tree find_name_in_single_imports PROTO ((tree)); +static void check_abstract_method_header PROTO ((tree)); +static tree lookup_java_interface_method2 PROTO ((tree, tree)); +static tree resolve_expression_name PROTO ((tree, tree *)); +static tree maybe_create_class_interface_decl PROTO ((tree, tree, tree)); +static int check_class_interface_creation PROTO ((int, int, tree, + tree, tree, tree)); +static tree patch_method_invocation PROTO ((tree, tree, tree, + int *, tree *)); +static int breakdown_qualified PROTO ((tree *, tree *, tree)); +static tree resolve_and_layout PROTO ((tree, tree)); +static tree resolve_no_layout PROTO ((tree, tree)); +static int invocation_mode PROTO ((tree, int)); +static tree find_applicable_accessible_methods_list PROTO ((int, tree, + tree, tree)); +static void search_applicable_methods_list PROTO ((int, tree, tree, tree, + tree *, tree *)); +static tree find_most_specific_methods_list PROTO ((tree)); +static int argument_types_convertible PROTO ((tree, tree)); +static tree patch_invoke PROTO ((tree, tree, tree)); +static tree lookup_method_invoke PROTO ((int, tree, tree, tree, tree)); +static tree register_incomplete_type PROTO ((int, tree, tree, tree)); +static tree obtain_incomplete_type PROTO ((tree)); +static tree java_complete_lhs PROTO ((tree)); +static tree java_complete_tree PROTO ((tree)); +static void java_complete_expand_method PROTO ((tree)); +static int unresolved_type_p PROTO ((tree, tree *)); +static void create_jdep_list PROTO ((struct parser_ctxt *)); +static tree build_expr_block PROTO ((tree, tree)); +static tree enter_block PROTO ((void)); +static tree enter_a_block PROTO ((tree)); +static tree exit_block PROTO ((void)); +static tree lookup_name_in_blocks PROTO ((tree)); +static void maybe_absorb_scoping_blocks PROTO ((void)); +static tree build_method_invocation PROTO ((tree, tree)); +static tree build_new_invocation PROTO ((tree, tree)); +static tree build_assignment PROTO ((int, int, tree, tree)); +static tree build_binop PROTO ((enum tree_code, int, tree, tree)); +static int check_final_assignment PROTO ((tree ,tree)); +static tree patch_assignment PROTO ((tree, tree, tree )); +static tree patch_binop PROTO ((tree, tree, tree)); +static tree build_unaryop PROTO ((int, int, tree)); +static tree build_incdec PROTO ((int, int, tree, int)); +static tree patch_unaryop PROTO ((tree, tree)); +static tree build_cast PROTO ((int, tree, tree)); +static tree build_null_of_type PROTO ((tree)); +static tree patch_cast PROTO ((tree, tree)); +static int valid_ref_assignconv_cast_p PROTO ((tree, tree, int)); +static int valid_builtin_assignconv_identity_widening_p PROTO ((tree, tree)); +static int valid_cast_to_p PROTO ((tree, tree)); +static int valid_method_invocation_conversion_p PROTO ((tree, tree)); +static tree try_builtin_assignconv PROTO ((tree, tree, tree)); +static tree try_reference_assignconv PROTO ((tree, tree)); +static tree build_unresolved_array_type PROTO ((tree)); +static tree build_array_from_name PROTO ((tree, tree, tree, tree *)); +static tree build_array_ref PROTO ((int, tree, tree)); +static tree patch_array_ref PROTO ((tree)); +static tree make_qualified_name PROTO ((tree, tree, int)); +static tree merge_qualified_name PROTO ((tree, tree)); +static tree make_qualified_primary PROTO ((tree, tree, int)); +static int resolve_qualified_expression_name PROTO ((tree, tree *, + tree *, tree *)); +static void qualify_ambiguous_name PROTO ((tree)); +static void maybe_generate_clinit PROTO ((void)); +static tree resolve_field_access PROTO ((tree, tree *, tree *)); +static tree build_newarray_node PROTO ((tree, tree, int)); +static tree patch_newarray PROTO ((tree)); +static tree resolve_type_during_patch PROTO ((tree)); +static tree build_this PROTO ((int)); +static tree build_return PROTO ((int, tree)); +static tree patch_return PROTO ((tree)); +static tree maybe_access_field PROTO ((tree, tree, tree)); +static int complete_function_arguments PROTO ((tree)); +static int check_for_static_method_reference PROTO ((tree, tree, tree, tree, tree)); +static int not_accessible_p PROTO ((tree, tree, int)); +static void check_deprecation PROTO ((tree, tree)); +static int class_in_current_package PROTO ((tree)); +static tree build_if_else_statement PROTO ((int, tree, tree, tree)); +static tree patch_if_else_statement PROTO ((tree)); +static tree add_stmt_to_compound PROTO ((tree, tree, tree)); +static tree add_stmt_to_block PROTO ((tree, tree, tree)); +static tree patch_exit_expr PROTO ((tree)); +static tree build_labeled_block PROTO ((int, tree)); +static tree finish_labeled_statement PROTO ((tree, tree)); +static tree build_bc_statement PROTO ((int, int, tree)); +static tree patch_bc_statement PROTO ((tree)); +static tree patch_loop_statement PROTO ((tree)); +static tree build_new_loop PROTO ((tree)); +static tree build_loop_body PROTO ((int, tree, int)); +static tree finish_loop_body PROTO ((int, tree, tree, int)); +static tree build_debugable_stmt PROTO ((int, tree)); +static tree finish_for_loop PROTO ((int, tree, tree, tree)); +static tree patch_switch_statement PROTO ((tree)); +static tree string_constant_concatenation PROTO ((tree, tree)); +static tree build_string_concatenation PROTO ((tree, tree)); +static tree patch_string_cst PROTO ((tree)); +static tree patch_string PROTO ((tree)); +static tree build_try_statement PROTO ((int, tree, tree)); +static tree build_try_finally_statement PROTO ((int, tree, tree)); +static tree patch_try_statement PROTO ((tree)); +static tree patch_synchronized_statement PROTO ((tree, tree)); +static tree patch_throw_statement PROTO ((tree, tree)); +static void check_thrown_exceptions PROTO ((int, tree)); +static int check_thrown_exceptions_do PROTO ((tree)); +static void purge_unchecked_exceptions PROTO ((tree)); +static void check_throws_clauses PROTO ((tree, tree, tree)); +static void finish_method_declaration PROTO ((tree)); +static tree build_super_invocation PROTO (()); +static int verify_constructor_circularity PROTO ((tree, tree)); +static char *constructor_circularity_msg PROTO ((tree, tree)); +static tree build_this_super_qualified_invocation PROTO ((int, tree, tree, + int, int)); +static char *get_printable_method_name PROTO ((tree)); +static tree patch_conditional_expr PROTO ((tree, tree, tree)); +static void maybe_generate_finit PROTO (()); +static void fix_constructors PROTO ((tree)); +static int verify_constructor_super PROTO (()); +static tree create_artificial_method PROTO ((tree, int, tree, tree, tree)); +static void start_artificial_method_body PROTO ((tree)); +static void end_artificial_method_body PROTO ((tree)); +static int check_method_redefinition PROTO ((tree, tree)); +static int reset_method_name PROTO ((tree)); +static void java_check_regular_methods PROTO ((tree)); +static void java_check_abstract_methods PROTO ((tree)); +static tree maybe_build_primttype_type_ref PROTO ((tree, tree)); +static void unreachable_stmt_error PROTO ((tree)); +static tree find_expr_with_wfl PROTO ((tree)); +static void missing_return_error PROTO ((tree)); +static tree build_new_array_init PROTO ((int, tree)); +static tree patch_new_array_init PROTO ((tree, tree)); +static tree maybe_build_array_element_wfl PROTO ((tree)); +static int array_constructor_check_entry PROTO ((tree, tree)); +static char *purify_type_name PROTO ((char *)); +static tree patch_initialized_static_field PROTO ((tree)); +static tree fold_constant_for_init PROTO ((tree, tree)); +static tree strip_out_static_field_access_decl PROTO ((tree)); +static jdeplist *reverse_jdep_list PROTO ((struct parser_ctxt *)); /* Number of error found so far. */ int java_error_count; @@ -151,6 +326,9 @@ int java_warning_count; /* The current parser context */ static struct parser_ctxt *ctxp; +/* List of things that were anlyzed for which code will be generated */ +static struct parser_ctxt *ctxp_for_generation = NULL; + /* binop_lookup maps token to tree_code. It is used where binary operations are involved and required by the parser. RDIV_EXPR covers both integral/floating point division. The code is changed @@ -170,12 +348,31 @@ static enum tree_code binop_lookup[19] = /* Fake WFL used to report error message. It is initialized once if needed and reused with it's location information is overriden. */ -static tree wfl_operator = NULL_TREE; +tree wfl_operator = NULL_TREE; /* The "$L" identifier we use to create labels. */ -static tree label_id; +static tree label_id = NULL_TREE; + +/* The "StringBuffer" identifier used for the String `+' operator. */ +static tree wfl_string_buffer = NULL_TREE; -#line 104 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +/* The "append" identifier used for String `+' operator. */ +static tree wfl_append = NULL_TREE; + +/* The "toString" identifier used for String `+' operator. */ +static tree wfl_to_string = NULL_TREE; + +/* The "java.lang" import qualified name. */ +static tree java_lang_id = NULL_TREE; + +/* The "java.lang.Cloneable" qualified name. */ +static tree java_lang_cloneable = NULL_TREE; + +/* Context and flag for static blocks */ +static tree current_static_block = NULL_TREE; + + +#line 300 "./parse.y" typedef union { tree node; int sub_token; @@ -185,6 +382,9 @@ typedef union { } operator; int value; } YYSTYPE; +#line 310 "./parse.y" + +#include "lex.c" #ifndef YYDEBUG #define YYDEBUG 1 #endif @@ -199,11 +399,11 @@ typedef union { -#define YYFINAL 772 +#define YYFINAL 775 #define YYFLAG -32768 #define YYNTBASE 110 -#define YYTRANSLATE(x) ((unsigned)(x) <= 364 ? yytranslate[x] : 259) +#define YYTRANSLATE(x) ((unsigned)(x) <= 364 ? yytranslate[x] : 265) static const char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -255,48 +455,48 @@ static const short yyprhs[] = { 0, 139, 141, 143, 145, 147, 149, 152, 153, 161, 162, 169, 173, 176, 180, 185, 186, 189, 193, 196, 197, 200, 203, 205, 209, 213, 216, 220, 222, 225, 227, - 229, 231, 233, 235, 237, 239, 241, 245, 250, 252, - 256, 260, 262, 266, 270, 275, 277, 281, 284, 288, - 292, 294, 296, 297, 301, 304, 308, 312, 317, 322, - 325, 329, 332, 336, 339, 343, 348, 352, 356, 360, - 362, 366, 370, 373, 377, 380, 384, 385, 388, 391, - 393, 397, 401, 403, 406, 408, 411, 415, 417, 421, - 426, 431, 437, 441, 446, 449, 453, 457, 462, 467, - 473, 481, 488, 490, 492, 493, 498, 499, 505, 506, - 512, 513, 520, 524, 529, 532, 536, 539, 543, 546, - 550, 552, 555, 557, 559, 561, 563, 565, 568, 571, - 574, 578, 582, 587, 589, 593, 597, 600, 601, 606, - 608, 611, 613, 615, 617, 620, 623, 627, 629, 631, - 633, 635, 637, 639, 641, 643, 645, 647, 649, 651, - 653, 655, 657, 659, 661, 663, 665, 667, 669, 671, - 673, 676, 679, 682, 685, 688, 691, 694, 697, 701, - 706, 711, 717, 722, 728, 735, 743, 750, 752, 754, - 756, 758, 760, 762, 764, 770, 773, 777, 782, 790, - 798, 804, 807, 811, 817, 820, 824, 828, 833, 835, - 838, 841, 843, 846, 850, 853, 856, 860, 863, 868, - 871, 874, 878, 883, 886, 888, 896, 904, 911, 915, - 921, 926, 934, 941, 944, 947, 951, 954, 955, 957, - 959, 962, 963, 965, 967, 971, 975, 978, 982, 985, - 989, 992, 996, 999, 1003, 1006, 1010, 1013, 1017, 1021, - 1024, 1028, 1034, 1040, 1043, 1048, 1052, 1054, 1058, 1062, - 1067, 1070, 1072, 1075, 1081, 1084, 1089, 1093, 1096, 1099, - 1101, 1103, 1105, 1107, 1111, 1113, 1115, 1117, 1119, 1123, - 1127, 1131, 1135, 1139, 1143, 1147, 1151, 1157, 1162, 1169, - 1175, 1180, 1186, 1192, 1199, 1203, 1207, 1212, 1218, 1221, - 1225, 1229, 1233, 1235, 1239, 1243, 1247, 1251, 1256, 1261, - 1266, 1271, 1275, 1279, 1281, 1284, 1288, 1292, 1295, 1298, - 1302, 1306, 1310, 1314, 1317, 1321, 1326, 1332, 1339, 1345, - 1352, 1357, 1362, 1367, 1372, 1376, 1381, 1385, 1390, 1392, - 1394, 1396, 1398, 1401, 1404, 1406, 1408, 1411, 1414, 1416, - 1419, 1422, 1425, 1428, 1431, 1434, 1436, 1439, 1442, 1444, - 1447, 1450, 1456, 1461, 1466, 1472, 1477, 1480, 1486, 1491, - 1497, 1499, 1503, 1507, 1511, 1515, 1519, 1523, 1525, 1529, - 1533, 1537, 1541, 1543, 1547, 1551, 1555, 1559, 1563, 1567, - 1569, 1573, 1577, 1581, 1585, 1589, 1593, 1597, 1601, 1605, - 1609, 1611, 1615, 1619, 1623, 1627, 1629, 1633, 1637, 1639, - 1643, 1647, 1649, 1653, 1657, 1659, 1663, 1667, 1669, 1673, - 1677, 1679, 1685, 1690, 1694, 1700, 1702, 1704, 1708, 1712, - 1714, 1716, 1718, 1720, 1722, 1724 + 229, 231, 233, 235, 238, 240, 242, 244, 248, 253, + 255, 259, 263, 265, 269, 273, 278, 280, 284, 287, + 291, 295, 297, 299, 300, 304, 307, 311, 315, 320, + 325, 328, 332, 335, 339, 342, 346, 351, 355, 359, + 363, 365, 369, 373, 376, 380, 383, 387, 388, 391, + 394, 396, 400, 404, 406, 409, 411, 414, 418, 420, + 421, 425, 428, 432, 436, 441, 444, 448, 452, 457, + 462, 468, 476, 483, 485, 487, 488, 493, 494, 500, + 501, 507, 508, 515, 519, 524, 527, 531, 534, 538, + 541, 545, 547, 550, 552, 554, 556, 558, 560, 563, + 566, 569, 573, 578, 580, 584, 588, 591, 595, 597, + 599, 601, 604, 606, 608, 610, 613, 616, 620, 622, + 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, + 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, + 664, 666, 669, 672, 675, 678, 681, 684, 687, 690, + 694, 699, 704, 710, 715, 721, 728, 736, 743, 745, + 747, 749, 751, 753, 755, 757, 763, 766, 770, 775, + 783, 791, 792, 796, 801, 804, 808, 814, 817, 821, + 825, 830, 832, 835, 838, 840, 843, 847, 850, 853, + 857, 860, 865, 868, 871, 875, 880, 883, 885, 893, + 901, 908, 912, 918, 923, 931, 938, 941, 944, 948, + 951, 952, 954, 956, 959, 960, 962, 964, 968, 972, + 975, 979, 982, 986, 989, 993, 996, 1000, 1003, 1007, + 1010, 1014, 1018, 1021, 1025, 1031, 1037, 1040, 1045, 1049, + 1051, 1055, 1059, 1064, 1067, 1069, 1072, 1075, 1080, 1083, + 1087, 1092, 1095, 1098, 1100, 1102, 1104, 1106, 1110, 1112, + 1114, 1116, 1118, 1122, 1126, 1130, 1134, 1138, 1142, 1146, + 1150, 1156, 1161, 1168, 1174, 1179, 1185, 1191, 1198, 1202, + 1206, 1211, 1217, 1220, 1224, 1228, 1232, 1234, 1238, 1242, + 1246, 1250, 1255, 1260, 1265, 1270, 1274, 1278, 1280, 1283, + 1287, 1291, 1294, 1297, 1301, 1305, 1309, 1313, 1316, 1320, + 1325, 1331, 1338, 1344, 1351, 1356, 1361, 1366, 1371, 1375, + 1380, 1384, 1389, 1391, 1393, 1395, 1397, 1400, 1403, 1405, + 1407, 1410, 1413, 1415, 1418, 1421, 1424, 1427, 1430, 1433, + 1435, 1438, 1441, 1443, 1446, 1449, 1455, 1460, 1465, 1471, + 1476, 1479, 1485, 1490, 1496, 1498, 1502, 1506, 1510, 1514, + 1518, 1522, 1524, 1528, 1532, 1536, 1540, 1542, 1546, 1550, + 1554, 1558, 1562, 1566, 1568, 1572, 1576, 1580, 1584, 1588, + 1592, 1596, 1600, 1604, 1608, 1610, 1614, 1618, 1622, 1626, + 1628, 1632, 1636, 1638, 1642, 1646, 1648, 1652, 1656, 1658, + 1662, 1666, 1668, 1672, 1676, 1678, 1684, 1689, 1693, 1699, + 1701, 1703, 1707, 1711, 1713, 1715, 1717, 1719, 1721, 1723 }; static const short yyrhs[] = { 123, @@ -314,7 +514,7 @@ static const short yyrhs[] = { 123, 55, 119, 99, 0, 55, 1, 0, 55, 119, 1, 0, 55, 119, 101, 5, 99, 0, 55, 119, 101, 1, 0, 55, 119, 101, 5, 1, 0, 132, 0, - 163, 0, 99, 0, 1, 0, 44, 0, 131, 44, + 165, 0, 99, 0, 1, 0, 44, 0, 131, 44, 0, 0, 131, 67, 122, 135, 136, 133, 138, 0, 0, 67, 122, 135, 136, 134, 138, 0, 131, 67, 1, 0, 67, 1, 0, 67, 122, 1, 0, 131, @@ -323,212 +523,212 @@ static const short yyrhs[] = { 123, 1, 0, 117, 0, 137, 100, 117, 0, 137, 100, 1, 0, 95, 96, 0, 95, 139, 96, 0, 140, 0, 139, 140, 0, 141, 0, 156, 0, 158, 0, - 176, 0, 142, 0, 147, 0, 132, 0, 163, 0, - 112, 143, 99, 0, 131, 112, 143, 99, 0, 144, - 0, 143, 100, 144, 0, 143, 100, 1, 0, 145, - 0, 145, 92, 146, 0, 145, 92, 1, 0, 145, - 92, 146, 1, 0, 122, 0, 145, 97, 98, 0, - 122, 1, 0, 145, 97, 1, 0, 145, 98, 1, - 0, 257, 0, 174, 0, 0, 149, 148, 155, 0, - 149, 1, 0, 112, 150, 153, 0, 59, 150, 153, - 0, 131, 112, 150, 153, 0, 131, 59, 150, 153, - 0, 112, 1, 0, 131, 112, 1, 0, 59, 1, - 0, 131, 59, 1, 0, 131, 1, 0, 122, 93, - 94, 0, 122, 93, 151, 94, 0, 150, 97, 98, - 0, 122, 93, 1, 0, 150, 97, 1, 0, 152, - 0, 151, 100, 152, 0, 151, 100, 1, 0, 112, - 145, 0, 131, 112, 145, 0, 112, 1, 0, 131, - 112, 1, 0, 0, 53, 154, 0, 53, 1, 0, - 116, 0, 154, 100, 116, 0, 154, 100, 1, 0, - 176, 0, 176, 99, 0, 99, 0, 157, 176, 0, - 157, 176, 99, 0, 44, 0, 159, 153, 160, 0, - 131, 159, 153, 160, 0, 159, 153, 160, 99, 0, - 131, 159, 153, 160, 99, 0, 120, 93, 94, 0, - 120, 93, 151, 94, 0, 95, 96, 0, 95, 161, - 96, 0, 95, 178, 96, 0, 95, 161, 178, 96, - 0, 162, 93, 94, 99, 0, 162, 93, 226, 94, - 99, 0, 119, 101, 65, 93, 226, 94, 99, 0, - 119, 101, 65, 93, 94, 99, 0, 76, 0, 65, - 0, 0, 61, 122, 164, 169, 0, 0, 131, 61, - 122, 165, 169, 0, 0, 61, 122, 168, 166, 169, - 0, 0, 131, 61, 122, 168, 167, 169, 0, 61, - 122, 1, 0, 131, 61, 122, 1, 0, 63, 117, - 0, 168, 100, 117, 0, 63, 1, 0, 168, 100, - 1, 0, 95, 96, 0, 95, 170, 96, 0, 171, - 0, 170, 171, 0, 172, 0, 173, 0, 132, 0, - 163, 0, 142, 0, 149, 99, 0, 149, 1, 0, - 95, 96, 0, 95, 175, 96, 0, 95, 100, 96, - 0, 95, 175, 100, 96, 0, 146, 0, 175, 100, - 146, 0, 175, 100, 1, 0, 95, 96, 0, 0, - 95, 177, 178, 96, 0, 179, 0, 178, 179, 0, - 180, 0, 182, 0, 132, 0, 181, 99, 0, 112, - 143, 0, 131, 112, 143, 0, 184, 0, 187, 0, - 191, 0, 192, 0, 201, 0, 205, 0, 184, 0, - 188, 0, 193, 0, 202, 0, 206, 0, 176, 0, - 185, 0, 189, 0, 194, 0, 204, 0, 212, 0, - 213, 0, 214, 0, 216, 0, 215, 0, 218, 0, - 99, 0, 122, 88, 0, 186, 182, 0, 122, 1, - 0, 186, 183, 0, 190, 99, 0, 1, 99, 0, - 1, 95, 0, 1, 96, 0, 162, 93, 1, 0, - 162, 93, 94, 1, 0, 162, 93, 226, 1, 0, - 162, 93, 226, 94, 1, 0, 119, 101, 65, 1, - 0, 119, 101, 65, 93, 1, 0, 119, 101, 65, - 93, 226, 1, 0, 119, 101, 65, 93, 226, 94, - 1, 0, 119, 101, 65, 93, 94, 1, 0, 254, - 0, 238, 0, 239, 0, 235, 0, 236, 0, 232, - 0, 224, 0, 48, 93, 257, 94, 182, 0, 48, - 1, 0, 48, 93, 1, 0, 48, 93, 257, 1, - 0, 48, 93, 257, 94, 183, 56, 182, 0, 48, - 93, 257, 94, 183, 56, 183, 0, 68, 93, 257, - 94, 195, 0, 68, 1, 0, 68, 93, 1, 0, - 68, 93, 257, 94, 1, 0, 95, 96, 0, 95, - 198, 96, 0, 95, 196, 96, 0, 95, 196, 198, - 96, 0, 197, 0, 196, 197, 0, 198, 178, 0, - 199, 0, 198, 199, 0, 62, 258, 88, 0, 47, - 88, 0, 62, 1, 0, 62, 258, 1, 0, 47, - 1, 0, 66, 93, 257, 94, 0, 200, 182, 0, - 66, 1, 0, 66, 93, 1, 0, 66, 93, 257, - 1, 0, 200, 183, 0, 51, 0, 203, 182, 66, - 93, 257, 94, 99, 0, 208, 99, 257, 99, 210, - 94, 182, 0, 208, 99, 99, 210, 94, 182, 0, - 208, 99, 1, 0, 208, 99, 257, 99, 1, 0, - 208, 99, 99, 1, 0, 208, 99, 257, 99, 210, - 94, 183, 0, 208, 99, 99, 210, 94, 183, 0, - 71, 93, 0, 71, 1, 0, 71, 93, 1, 0, - 207, 209, 0, 0, 211, 0, 181, 0, 211, 1, - 0, 0, 211, 0, 190, 0, 211, 100, 190, 0, - 211, 100, 1, 0, 54, 99, 0, 54, 122, 99, - 0, 54, 1, 0, 54, 122, 1, 0, 73, 99, - 0, 73, 122, 99, 0, 73, 1, 0, 73, 122, - 1, 0, 58, 99, 0, 58, 257, 99, 0, 58, - 1, 0, 58, 257, 1, 0, 49, 257, 99, 0, - 49, 1, 0, 49, 257, 1, 0, 217, 93, 257, - 94, 176, 0, 217, 93, 257, 94, 1, 0, 217, - 1, 0, 217, 93, 1, 94, 0, 217, 93, 1, - 0, 44, 0, 70, 176, 219, 0, 70, 176, 221, - 0, 70, 176, 219, 221, 0, 70, 1, 0, 220, - 0, 219, 220, 0, 60, 93, 152, 94, 176, 0, - 60, 1, 0, 60, 93, 1, 94, 0, 60, 93, - 1, 0, 64, 176, 0, 64, 1, 0, 223, 0, - 227, 0, 111, 0, 76, 0, 93, 257, 94, 0, - 224, 0, 231, 0, 232, 0, 233, 0, 119, 101, - 67, 0, 113, 101, 67, 0, 59, 101, 67, 0, - 119, 101, 76, 0, 93, 257, 1, 0, 119, 101, - 1, 0, 113, 101, 1, 0, 59, 101, 1, 0, - 72, 116, 93, 226, 94, 0, 72, 116, 93, 94, - 0, 72, 116, 93, 226, 94, 138, 0, 72, 116, - 93, 94, 138, 0, 225, 122, 93, 94, 0, 225, - 122, 93, 94, 138, 0, 225, 122, 93, 226, 94, - 0, 225, 122, 93, 226, 94, 138, 0, 72, 1, - 99, 0, 72, 116, 1, 0, 72, 116, 93, 1, - 0, 72, 116, 93, 226, 1, 0, 225, 1, 0, - 225, 122, 1, 0, 119, 101, 72, 0, 222, 101, - 72, 0, 257, 0, 226, 100, 257, 0, 226, 100, - 1, 0, 72, 113, 228, 0, 72, 115, 228, 0, - 72, 113, 228, 230, 0, 72, 115, 228, 230, 0, - 72, 115, 230, 174, 0, 72, 113, 230, 174, 0, - 72, 1, 98, 0, 72, 1, 97, 0, 229, 0, - 228, 229, 0, 97, 257, 98, 0, 97, 257, 1, - 0, 97, 1, 0, 97, 98, 0, 230, 97, 98, - 0, 230, 97, 1, 0, 222, 101, 122, 0, 65, - 101, 122, 0, 65, 1, 0, 119, 93, 94, 0, - 119, 93, 226, 94, 0, 222, 101, 122, 93, 94, - 0, 222, 101, 122, 93, 226, 94, 0, 65, 101, - 122, 93, 94, 0, 65, 101, 122, 93, 226, 94, - 0, 65, 101, 1, 94, 0, 65, 101, 1, 101, - 0, 119, 97, 257, 98, 0, 223, 97, 257, 98, - 0, 119, 97, 1, 0, 119, 97, 257, 1, 0, - 223, 97, 1, 0, 223, 97, 257, 1, 0, 222, - 0, 119, 0, 235, 0, 236, 0, 234, 46, 0, - 234, 45, 0, 238, 0, 239, 0, 3, 237, 0, - 4, 237, 0, 240, 0, 3, 1, 0, 4, 1, - 0, 46, 237, 0, 46, 1, 0, 45, 237, 0, - 45, 1, 0, 234, 0, 89, 237, 0, 90, 237, - 0, 241, 0, 89, 1, 0, 90, 1, 0, 93, - 113, 230, 94, 237, 0, 93, 113, 94, 237, 0, - 93, 257, 94, 240, 0, 93, 119, 230, 94, 240, - 0, 93, 113, 97, 1, 0, 93, 1, 0, 93, - 113, 230, 94, 1, 0, 93, 113, 94, 1, 0, - 93, 119, 230, 94, 1, 0, 237, 0, 242, 5, - 237, 0, 242, 6, 237, 0, 242, 7, 237, 0, - 242, 5, 1, 0, 242, 6, 1, 0, 242, 7, - 1, 0, 242, 0, 243, 3, 242, 0, 243, 4, - 242, 0, 243, 3, 1, 0, 243, 4, 1, 0, - 243, 0, 244, 8, 243, 0, 244, 9, 243, 0, - 244, 10, 243, 0, 244, 8, 1, 0, 244, 9, - 1, 0, 244, 10, 1, 0, 244, 0, 245, 20, - 244, 0, 245, 18, 244, 0, 245, 21, 244, 0, - 245, 19, 244, 0, 245, 57, 114, 0, 245, 20, - 1, 0, 245, 18, 1, 0, 245, 21, 1, 0, - 245, 19, 1, 0, 245, 57, 1, 0, 245, 0, - 246, 16, 245, 0, 246, 17, 245, 0, 246, 16, - 1, 0, 246, 17, 1, 0, 246, 0, 247, 11, - 246, 0, 247, 11, 1, 0, 247, 0, 248, 12, - 247, 0, 248, 12, 1, 0, 248, 0, 249, 13, - 248, 0, 249, 13, 1, 0, 249, 0, 250, 14, - 249, 0, 250, 14, 1, 0, 250, 0, 251, 15, - 250, 0, 251, 15, 1, 0, 251, 0, 251, 87, - 257, 88, 252, 0, 251, 87, 88, 1, 0, 251, - 87, 1, 0, 251, 87, 257, 88, 1, 0, 252, - 0, 254, 0, 255, 256, 253, 0, 255, 256, 1, - 0, 119, 0, 231, 0, 233, 0, 91, 0, 92, - 0, 253, 0, 257, 0 + 178, 0, 142, 0, 142, 99, 0, 147, 0, 132, + 0, 165, 0, 112, 143, 99, 0, 131, 112, 143, + 99, 0, 144, 0, 143, 100, 144, 0, 143, 100, + 1, 0, 145, 0, 145, 92, 146, 0, 145, 92, + 1, 0, 145, 92, 146, 1, 0, 122, 0, 145, + 97, 98, 0, 122, 1, 0, 145, 97, 1, 0, + 145, 98, 1, 0, 263, 0, 176, 0, 0, 149, + 148, 155, 0, 149, 1, 0, 112, 150, 153, 0, + 59, 150, 153, 0, 131, 112, 150, 153, 0, 131, + 59, 150, 153, 0, 112, 1, 0, 131, 112, 1, + 0, 59, 1, 0, 131, 59, 1, 0, 131, 1, + 0, 122, 93, 94, 0, 122, 93, 151, 94, 0, + 150, 97, 98, 0, 122, 93, 1, 0, 150, 97, + 1, 0, 152, 0, 151, 100, 152, 0, 151, 100, + 1, 0, 112, 145, 0, 131, 112, 145, 0, 112, + 1, 0, 131, 112, 1, 0, 0, 53, 154, 0, + 53, 1, 0, 116, 0, 154, 100, 116, 0, 154, + 100, 1, 0, 178, 0, 178, 99, 0, 99, 0, + 157, 178, 0, 157, 178, 99, 0, 44, 0, 0, + 160, 159, 162, 0, 161, 153, 0, 131, 161, 153, + 0, 120, 93, 94, 0, 120, 93, 151, 94, 0, + 179, 180, 0, 179, 163, 180, 0, 179, 181, 180, + 0, 179, 163, 181, 180, 0, 164, 93, 94, 99, + 0, 164, 93, 232, 94, 99, 0, 119, 101, 65, + 93, 232, 94, 99, 0, 119, 101, 65, 93, 94, + 99, 0, 76, 0, 65, 0, 0, 61, 122, 166, + 171, 0, 0, 131, 61, 122, 167, 171, 0, 0, + 61, 122, 170, 168, 171, 0, 0, 131, 61, 122, + 170, 169, 171, 0, 61, 122, 1, 0, 131, 61, + 122, 1, 0, 63, 117, 0, 170, 100, 117, 0, + 63, 1, 0, 170, 100, 1, 0, 95, 96, 0, + 95, 172, 96, 0, 173, 0, 172, 173, 0, 174, + 0, 175, 0, 132, 0, 165, 0, 142, 0, 149, + 99, 0, 149, 1, 0, 95, 96, 0, 95, 177, + 96, 0, 95, 177, 100, 96, 0, 146, 0, 177, + 100, 146, 0, 177, 100, 1, 0, 95, 96, 0, + 179, 181, 180, 0, 95, 0, 96, 0, 182, 0, + 181, 182, 0, 183, 0, 185, 0, 132, 0, 184, + 99, 0, 112, 143, 0, 131, 112, 143, 0, 187, + 0, 190, 0, 194, 0, 195, 0, 206, 0, 210, + 0, 187, 0, 191, 0, 196, 0, 207, 0, 211, + 0, 178, 0, 188, 0, 192, 0, 197, 0, 209, + 0, 217, 0, 218, 0, 219, 0, 221, 0, 220, + 0, 223, 0, 99, 0, 122, 88, 0, 189, 185, + 0, 122, 1, 0, 189, 186, 0, 193, 99, 0, + 1, 99, 0, 1, 95, 0, 1, 96, 0, 164, + 93, 1, 0, 164, 93, 94, 1, 0, 164, 93, + 232, 1, 0, 164, 93, 232, 94, 1, 0, 119, + 101, 65, 1, 0, 119, 101, 65, 93, 1, 0, + 119, 101, 65, 93, 232, 1, 0, 119, 101, 65, + 93, 232, 94, 1, 0, 119, 101, 65, 93, 94, + 1, 0, 260, 0, 244, 0, 245, 0, 241, 0, + 242, 0, 238, 0, 230, 0, 48, 93, 263, 94, + 185, 0, 48, 1, 0, 48, 93, 1, 0, 48, + 93, 263, 1, 0, 48, 93, 263, 94, 186, 56, + 185, 0, 48, 93, 263, 94, 186, 56, 186, 0, + 0, 199, 198, 200, 0, 68, 93, 263, 94, 0, + 68, 1, 0, 68, 93, 1, 0, 68, 93, 263, + 94, 1, 0, 95, 96, 0, 95, 203, 96, 0, + 95, 201, 96, 0, 95, 201, 203, 96, 0, 202, + 0, 201, 202, 0, 203, 181, 0, 204, 0, 203, + 204, 0, 62, 264, 88, 0, 47, 88, 0, 62, + 1, 0, 62, 264, 1, 0, 47, 1, 0, 66, + 93, 263, 94, 0, 205, 185, 0, 66, 1, 0, + 66, 93, 1, 0, 66, 93, 263, 1, 0, 205, + 186, 0, 51, 0, 208, 185, 66, 93, 263, 94, + 99, 0, 213, 99, 263, 99, 215, 94, 185, 0, + 213, 99, 99, 215, 94, 185, 0, 213, 99, 1, + 0, 213, 99, 263, 99, 1, 0, 213, 99, 99, + 1, 0, 213, 99, 263, 99, 215, 94, 186, 0, + 213, 99, 99, 215, 94, 186, 0, 71, 93, 0, + 71, 1, 0, 71, 93, 1, 0, 212, 214, 0, + 0, 216, 0, 184, 0, 216, 1, 0, 0, 216, + 0, 193, 0, 216, 100, 193, 0, 216, 100, 1, + 0, 54, 99, 0, 54, 122, 99, 0, 54, 1, + 0, 54, 122, 1, 0, 73, 99, 0, 73, 122, + 99, 0, 73, 1, 0, 73, 122, 1, 0, 58, + 99, 0, 58, 263, 99, 0, 58, 1, 0, 58, + 263, 1, 0, 49, 263, 99, 0, 49, 1, 0, + 49, 263, 1, 0, 222, 93, 263, 94, 178, 0, + 222, 93, 263, 94, 1, 0, 222, 1, 0, 222, + 93, 1, 94, 0, 222, 93, 1, 0, 44, 0, + 70, 178, 224, 0, 70, 178, 227, 0, 70, 178, + 224, 227, 0, 70, 1, 0, 225, 0, 224, 225, + 0, 226, 178, 0, 60, 93, 152, 94, 0, 60, + 1, 0, 60, 93, 1, 0, 60, 93, 1, 94, + 0, 64, 178, 0, 64, 1, 0, 229, 0, 233, + 0, 111, 0, 76, 0, 93, 263, 94, 0, 230, + 0, 237, 0, 238, 0, 239, 0, 119, 101, 67, + 0, 113, 101, 67, 0, 59, 101, 67, 0, 119, + 101, 76, 0, 93, 263, 1, 0, 119, 101, 1, + 0, 113, 101, 1, 0, 59, 101, 1, 0, 72, + 116, 93, 232, 94, 0, 72, 116, 93, 94, 0, + 72, 116, 93, 232, 94, 138, 0, 72, 116, 93, + 94, 138, 0, 231, 122, 93, 94, 0, 231, 122, + 93, 94, 138, 0, 231, 122, 93, 232, 94, 0, + 231, 122, 93, 232, 94, 138, 0, 72, 1, 99, + 0, 72, 116, 1, 0, 72, 116, 93, 1, 0, + 72, 116, 93, 232, 1, 0, 231, 1, 0, 231, + 122, 1, 0, 119, 101, 72, 0, 228, 101, 72, + 0, 263, 0, 232, 100, 263, 0, 232, 100, 1, + 0, 72, 113, 234, 0, 72, 115, 234, 0, 72, + 113, 234, 236, 0, 72, 115, 234, 236, 0, 72, + 115, 236, 176, 0, 72, 113, 236, 176, 0, 72, + 1, 98, 0, 72, 1, 97, 0, 235, 0, 234, + 235, 0, 97, 263, 98, 0, 97, 263, 1, 0, + 97, 1, 0, 97, 98, 0, 236, 97, 98, 0, + 236, 97, 1, 0, 228, 101, 122, 0, 65, 101, + 122, 0, 65, 1, 0, 119, 93, 94, 0, 119, + 93, 232, 94, 0, 228, 101, 122, 93, 94, 0, + 228, 101, 122, 93, 232, 94, 0, 65, 101, 122, + 93, 94, 0, 65, 101, 122, 93, 232, 94, 0, + 65, 101, 1, 94, 0, 65, 101, 1, 101, 0, + 119, 97, 263, 98, 0, 229, 97, 263, 98, 0, + 119, 97, 1, 0, 119, 97, 263, 1, 0, 229, + 97, 1, 0, 229, 97, 263, 1, 0, 228, 0, + 119, 0, 241, 0, 242, 0, 240, 46, 0, 240, + 45, 0, 244, 0, 245, 0, 3, 243, 0, 4, + 243, 0, 246, 0, 3, 1, 0, 4, 1, 0, + 46, 243, 0, 46, 1, 0, 45, 243, 0, 45, + 1, 0, 240, 0, 89, 243, 0, 90, 243, 0, + 247, 0, 89, 1, 0, 90, 1, 0, 93, 113, + 236, 94, 243, 0, 93, 113, 94, 243, 0, 93, + 263, 94, 246, 0, 93, 119, 236, 94, 246, 0, + 93, 113, 97, 1, 0, 93, 1, 0, 93, 113, + 236, 94, 1, 0, 93, 113, 94, 1, 0, 93, + 119, 236, 94, 1, 0, 243, 0, 248, 5, 243, + 0, 248, 6, 243, 0, 248, 7, 243, 0, 248, + 5, 1, 0, 248, 6, 1, 0, 248, 7, 1, + 0, 248, 0, 249, 3, 248, 0, 249, 4, 248, + 0, 249, 3, 1, 0, 249, 4, 1, 0, 249, + 0, 250, 8, 249, 0, 250, 9, 249, 0, 250, + 10, 249, 0, 250, 8, 1, 0, 250, 9, 1, + 0, 250, 10, 1, 0, 250, 0, 251, 20, 250, + 0, 251, 18, 250, 0, 251, 21, 250, 0, 251, + 19, 250, 0, 251, 57, 114, 0, 251, 20, 1, + 0, 251, 18, 1, 0, 251, 21, 1, 0, 251, + 19, 1, 0, 251, 57, 1, 0, 251, 0, 252, + 16, 251, 0, 252, 17, 251, 0, 252, 16, 1, + 0, 252, 17, 1, 0, 252, 0, 253, 11, 252, + 0, 253, 11, 1, 0, 253, 0, 254, 12, 253, + 0, 254, 12, 1, 0, 254, 0, 255, 13, 254, + 0, 255, 13, 1, 0, 255, 0, 256, 14, 255, + 0, 256, 14, 1, 0, 256, 0, 257, 15, 256, + 0, 257, 15, 1, 0, 257, 0, 257, 87, 263, + 88, 258, 0, 257, 87, 88, 1, 0, 257, 87, + 1, 0, 257, 87, 263, 88, 1, 0, 258, 0, + 260, 0, 261, 262, 259, 0, 261, 262, 1, 0, + 119, 0, 237, 0, 239, 0, 91, 0, 92, 0, + 259, 0, 263, 0 }; #endif #if YYDEBUG != 0 static const short yyrline[] = { 0, - 251, 257, 259, 260, 261, 262, 263, 267, 269, 272, - 274, 275, 278, 280, 283, 287, 291, 295, 301, 303, - 305, 307, 312, 314, 317, 321, 326, 331, 333, 334, - 335, 336, 337, 338, 339, 342, 347, 353, 355, 358, - 361, 363, 367, 369, 372, 402, 404, 408, 421, 423, - 427, 433, 434, 436, 446, 451, 466, 470, 473, 476, - 479, 481, 483, 485, 489, 491, 493, 495, 499, 501, - 503, 510, 516, 521, 525, 528, 532, 534, 537, 539, - 540, 541, 544, 546, 547, 548, 552, 555, 567, 570, - 572, 576, 579, 586, 592, 600, 602, 606, 608, 610, - 614, 616, 621, 628, 640, 644, 647, 649, 651, 653, - 655, 657, 659, 661, 668, 671, 673, 678, 680, 684, - 689, 694, 698, 703, 708, 710, 717, 718, 719, 723, - 725, 726, 730, 732, 733, 738, 743, 749, 761, 766, - 772, 777, 786, 788, 791, 793, 794, 795, 799, 801, - 804, 805, 809, 816, 826, 830, 833, 836, 839, 842, - 845, 848, 851, 853, 857, 863, 868, 870, 874, 877, - 881, 883, 886, 888, 889, 890, 893, 897, 903, 908, - 913, 917, 921, 927, 929, 930, 935, 938, 941, 948, - 950, 953, 955, 957, 960, 964, 967, 971, 973, 975, - 977, 979, 981, 991, 993, 995, 997, 999, 1003, 1006, - 1008, 1010, 1012, 1014, 1016, 1018, 1019, 1021, 1023, 1027, - 1032, 1043, 1050, 1054, 1065, 1075, 1081, 1087, 1093, 1095, - 1097, 1099, 1101, 1103, 1105, 1107, 1109, 1113, 1115, 1119, - 1123, 1127, 1131, 1132, 1138, 1141, 1143, 1145, 1149, 1154, - 1159, 1161, 1163, 1165, 1169, 1171, 1172, 1173, 1176, 1178, - 1181, 1186, 1188, 1191, 1193, 1194, 1196, 1198, 1202, 1210, - 1213, 1215, 1217, 1221, 1226, 1235, 1240, 1243, 1250, 1252, - 1254, 1258, 1261, 1270, 1277, 1279, 1283, 1296, 1298, 1304, - 1310, 1314, 1316, 1320, 1323, 1325, 1329, 1332, 1334, 1336, - 1340, 1343, 1345, 1347, 1351, 1354, 1356, 1358, 1362, 1364, - 1366, 1370, 1372, 1374, 1376, 1378, 1382, 1389, 1391, 1392, - 1393, 1397, 1399, 1402, 1404, 1406, 1408, 1412, 1414, 1419, - 1421, 1424, 1426, 1428, 1430, 1431, 1432, 1433, 1437, 1438, - 1439, 1443, 1444, 1446, 1448, 1450, 1454, 1460, 1468, 1470, - 1475, 1476, 1477, 1478, 1479, 1481, 1483, 1485, 1487, 1489, - 1493, 1495, 1498, 1504, 1509, 1513, 1516, 1518, 1520, 1524, - 1526, 1528, 1530, 1534, 1537, 1541, 1547, 1549, 1557, 1560, - 1562, 1566, 1569, 1576, 1580, 1583, 1585, 1590, 1595, 1603, - 1615, 1617, 1621, 1624, 1626, 1631, 1636, 1641, 1648, 1650, - 1651, 1652, 1655, 1660, 1665, 1667, 1668, 1670, 1672, 1673, - 1675, 1679, 1682, 1686, 1689, 1693, 1695, 1697, 1699, 1700, - 1702, 1706, 1714, 1716, 1718, 1730, 1732, 1738, 1740, 1742, - 1746, 1748, 1753, 1758, 1763, 1765, 1767, 1771, 1773, 1778, - 1783, 1785, 1789, 1791, 1796, 1801, 1806, 1808, 1810, 1814, - 1816, 1821, 1826, 1831, 1836, 1837, 1839, 1841, 1843, 1845, - 1849, 1851, 1856, 1861, 1863, 1867, 1869, 1874, 1878, 1880, - 1885, 1889, 1891, 1896, 1900, 1902, 1907, 1911, 1913, 1918, - 1922, 1924, 1925, 1931, 1933, 1937, 1939, 1942, 1945, 1953, - 1955, 1956, 1959, 1961, 1964, 1968 + 454, 460, 462, 463, 464, 465, 466, 470, 472, 475, + 477, 478, 481, 483, 486, 490, 494, 498, 504, 506, + 508, 510, 515, 517, 520, 524, 529, 534, 536, 537, + 538, 539, 540, 541, 542, 545, 550, 556, 558, 561, + 564, 566, 570, 572, 575, 602, 604, 608, 621, 623, + 627, 634, 635, 637, 647, 652, 667, 671, 674, 677, + 680, 682, 684, 689, 693, 695, 697, 699, 703, 705, + 707, 714, 720, 725, 729, 732, 736, 738, 741, 743, + 744, 745, 749, 751, 753, 754, 756, 761, 764, 774, + 777, 779, 783, 786, 793, 799, 807, 809, 811, 813, + 815, 819, 821, 825, 832, 833, 837, 840, 842, 844, + 846, 848, 850, 852, 854, 861, 864, 866, 875, 877, + 881, 886, 891, 895, 900, 902, 904, 911, 913, 915, + 919, 922, 924, 928, 930, 931, 936, 942, 949, 957, + 964, 967, 970, 974, 977, 981, 990, 992, 994, 999, + 1006, 1014, 1016, 1020, 1027, 1037, 1041, 1044, 1047, 1050, + 1053, 1056, 1059, 1062, 1064, 1068, 1074, 1079, 1081, 1085, + 1088, 1092, 1094, 1097, 1099, 1100, 1102, 1106, 1110, 1116, + 1121, 1124, 1126, 1130, 1136, 1140, 1145, 1148, 1152, 1157, + 1165, 1167, 1170, 1172, 1174, 1178, 1182, 1185, 1189, 1191, + 1192, 1193, 1194, 1195, 1205, 1207, 1208, 1209, 1210, 1213, + 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, + 1227, 1232, 1243, 1246, 1250, 1257, 1267, 1273, 1279, 1285, + 1287, 1293, 1295, 1301, 1303, 1305, 1307, 1309, 1313, 1315, + 1316, 1317, 1318, 1319, 1320, 1323, 1329, 1331, 1333, 1337, + 1342, 1347, 1353, 1363, 1369, 1371, 1373, 1380, 1383, 1385, + 1387, 1391, 1393, 1396, 1400, 1402, 1405, 1412, 1418, 1420, + 1422, 1426, 1434, 1437, 1439, 1441, 1445, 1450, 1459, 1464, + 1467, 1474, 1476, 1478, 1482, 1485, 1494, 1501, 1503, 1507, + 1520, 1522, 1528, 1534, 1538, 1540, 1544, 1547, 1549, 1553, + 1556, 1558, 1560, 1564, 1567, 1569, 1571, 1575, 1578, 1580, + 1582, 1586, 1592, 1594, 1598, 1605, 1607, 1609, 1611, 1615, + 1623, 1626, 1628, 1633, 1637, 1639, 1646, 1654, 1671, 1673, + 1675, 1679, 1682, 1687, 1689, 1692, 1694, 1696, 1698, 1699, + 1700, 1701, 1705, 1707, 1709, 1714, 1716, 1718, 1720, 1722, + 1726, 1729, 1734, 1736, 1741, 1742, 1743, 1744, 1745, 1747, + 1749, 1751, 1753, 1755, 1759, 1761, 1764, 1770, 1775, 1779, + 1782, 1784, 1786, 1790, 1792, 1794, 1796, 1800, 1803, 1807, + 1813, 1815, 1823, 1850, 1852, 1856, 1861, 1868, 1872, 1875, + 1877, 1888, 1899, 1904, 1913, 1915, 1919, 1922, 1924, 1929, + 1934, 1939, 1946, 1948, 1949, 1950, 1953, 1958, 1963, 1965, + 1966, 1968, 1970, 1971, 1973, 1977, 1980, 1984, 1987, 1991, + 1993, 1995, 1997, 1998, 2000, 2004, 2013, 2015, 2017, 2030, + 2032, 2038, 2040, 2042, 2046, 2048, 2053, 2058, 2063, 2065, + 2067, 2071, 2073, 2078, 2083, 2085, 2089, 2091, 2096, 2101, + 2106, 2108, 2110, 2114, 2116, 2121, 2126, 2131, 2136, 2138, + 2140, 2142, 2144, 2146, 2150, 2152, 2157, 2162, 2164, 2168, + 2170, 2175, 2179, 2181, 2186, 2190, 2192, 2197, 2201, 2203, + 2208, 2212, 2214, 2219, 2223, 2225, 2230, 2236, 2238, 2242, + 2244, 2247, 2250, 2258, 2260, 2261, 2264, 2266, 2269, 2273 }; #endif @@ -560,30 +760,31 @@ static const char * const yytname[] = { "$","error","$undefined.","PLUS_TK", "class_member_declaration","field_declaration","variable_declarators","variable_declarator", "variable_declarator_id","variable_initializer","method_declaration","@3","method_header", "method_declarator","formal_parameter_list","formal_parameter","throws","class_type_list", -"method_body","static_initializer","static","constructor_declaration","constructor_declarator", -"constructor_body","explicit_constructor_invocation","this_or_super","interface_declaration", -"@4","@5","@6","@7","extends_interfaces","interface_body","interface_member_declarations", -"interface_member_declaration","constant_declaration","abstract_method_declaration", -"array_initializer","variable_initializers","block","@8","block_statements", -"block_statement","local_variable_declaration_statement","local_variable_declaration", -"statement","statement_nsi","statement_without_trailing_substatement","empty_statement", -"label_decl","labeled_statement","labeled_statement_nsi","expression_statement", +"method_body","static_initializer","static","constructor_declaration","@4","constructor_header", +"constructor_declarator","constructor_body","explicit_constructor_invocation", +"this_or_super","interface_declaration","@5","@6","@7","@8","extends_interfaces", +"interface_body","interface_member_declarations","interface_member_declaration", +"constant_declaration","abstract_method_declaration","array_initializer","variable_initializers", +"block","block_begin","block_end","block_statements","block_statement","local_variable_declaration_statement", +"local_variable_declaration","statement","statement_nsi","statement_without_trailing_substatement", +"empty_statement","label_decl","labeled_statement","labeled_statement_nsi","expression_statement", "statement_expression","if_then_statement","if_then_else_statement","if_then_else_statement_nsi", -"switch_statement","switch_block","switch_block_statement_groups","switch_block_statement_group", -"switch_labels","switch_label","while_expression","while_statement","while_statement_nsi", -"do_statement_begin","do_statement","for_statement","for_statement_nsi","for_header", -"for_begin","for_init","for_update","statement_expression_list","break_statement", -"continue_statement","return_statement","throw_statement","synchronized_statement", -"synchronized","try_statement","catches","catch_clause","finally","primary", -"primary_no_new_array","class_instance_creation_expression","something_dot_new", -"argument_list","array_creation_expression","dim_exprs","dim_expr","dims","field_access", -"method_invocation","array_access","postfix_expression","post_increment_expression", -"post_decrement_expression","unary_expression","pre_increment_expression","pre_decrement_expression", -"unary_expression_not_plus_minus","cast_expression","multiplicative_expression", -"additive_expression","shift_expression","relational_expression","equality_expression", -"and_expression","exclusive_or_expression","inclusive_or_expression","conditional_and_expression", -"conditional_or_expression","conditional_expression","assignment_expression", -"assignment","left_hand_side","assignment_operator","expression","constant_expression", NULL +"switch_statement","@9","switch_expression","switch_block","switch_block_statement_groups", +"switch_block_statement_group","switch_labels","switch_label","while_expression", +"while_statement","while_statement_nsi","do_statement_begin","do_statement", +"for_statement","for_statement_nsi","for_header","for_begin","for_init","for_update", +"statement_expression_list","break_statement","continue_statement","return_statement", +"throw_statement","synchronized_statement","synchronized","try_statement","catches", +"catch_clause","catch_clause_parameter","finally","primary","primary_no_new_array", +"class_instance_creation_expression","something_dot_new","argument_list","array_creation_expression", +"dim_exprs","dim_expr","dims","field_access","method_invocation","array_access", +"postfix_expression","post_increment_expression","post_decrement_expression", +"unary_expression","pre_increment_expression","pre_decrement_expression","unary_expression_not_plus_minus", +"cast_expression","multiplicative_expression","additive_expression","shift_expression", +"relational_expression","equality_expression","and_expression","exclusive_or_expression", +"inclusive_or_expression","conditional_and_expression","conditional_or_expression", +"conditional_expression","assignment_expression","assignment","left_hand_side", +"assignment_operator","expression","constant_expression", NULL }; #endif @@ -596,48 +797,48 @@ static const short yyr1[] = { 0, 130, 130, 130, 130, 131, 131, 133, 132, 134, 132, 132, 132, 132, 132, 135, 135, 135, 135, 136, 136, 136, 137, 137, 137, 138, 138, 139, 139, 140, 140, - 140, 140, 141, 141, 141, 141, 142, 142, 143, 143, - 143, 144, 144, 144, 144, 145, 145, 145, 145, 145, - 146, 146, 148, 147, 147, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 150, 150, 150, 150, 150, 151, - 151, 151, 152, 152, 152, 152, 153, 153, 153, 154, - 154, 154, 155, 155, 155, 156, 156, 157, 158, 158, - 158, 158, 159, 159, 160, 160, 160, 160, 161, 161, - 161, 161, 162, 162, 164, 163, 165, 163, 166, 163, - 167, 163, 163, 163, 168, 168, 168, 168, 169, 169, - 170, 170, 171, 171, 171, 171, 172, 173, 173, 174, - 174, 174, 174, 175, 175, 175, 176, 177, 176, 178, - 178, 179, 179, 179, 180, 181, 181, 182, 182, 182, - 182, 182, 182, 183, 183, 183, 183, 183, 184, 184, - 184, 184, 184, 184, 184, 184, 184, 184, 184, 185, - 186, 187, 187, 188, 189, 189, 189, 189, 189, 189, - 189, 189, 189, 189, 189, 189, 189, 190, 190, 190, - 190, 190, 190, 190, 191, 191, 191, 191, 192, 193, - 194, 194, 194, 194, 195, 195, 195, 195, 196, 196, - 197, 198, 198, 199, 199, 199, 199, 199, 200, 201, - 201, 201, 201, 202, 203, 204, 205, 205, 205, 205, - 205, 206, 206, 207, 207, 207, 208, 209, 209, 209, - 209, 210, 210, 211, 211, 211, 212, 212, 212, 212, - 213, 213, 213, 213, 214, 214, 214, 214, 215, 215, - 215, 216, 216, 216, 216, 216, 217, 218, 218, 218, - 218, 219, 219, 220, 220, 220, 220, 221, 221, 222, - 222, 223, 223, 223, 223, 223, 223, 223, 223, 223, - 223, 223, 223, 223, 223, 223, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, - 225, 225, 226, 226, 226, 227, 227, 227, 227, 227, - 227, 227, 227, 228, 228, 229, 229, 229, 230, 230, - 230, 231, 231, 231, 232, 232, 232, 232, 232, 232, - 232, 232, 233, 233, 233, 233, 233, 233, 234, 234, - 234, 234, 235, 236, 237, 237, 237, 237, 237, 237, - 237, 238, 238, 239, 239, 240, 240, 240, 240, 240, - 240, 241, 241, 241, 241, 241, 241, 241, 241, 241, - 242, 242, 242, 242, 242, 242, 242, 243, 243, 243, - 243, 243, 244, 244, 244, 244, 244, 244, 244, 245, - 245, 245, 245, 245, 245, 245, 245, 245, 245, 245, - 246, 246, 246, 246, 246, 247, 247, 247, 248, 248, - 248, 249, 249, 249, 250, 250, 250, 251, 251, 251, - 252, 252, 252, 252, 252, 253, 253, 254, 254, 255, - 255, 255, 256, 256, 257, 258 + 140, 140, 141, 141, 141, 141, 141, 142, 142, 143, + 143, 143, 144, 144, 144, 144, 145, 145, 145, 145, + 145, 146, 146, 148, 147, 147, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 150, 150, 150, 150, 150, + 151, 151, 151, 152, 152, 152, 152, 153, 153, 153, + 154, 154, 154, 155, 155, 155, 156, 156, 157, 159, + 158, 160, 160, 161, 161, 162, 162, 162, 162, 163, + 163, 163, 163, 164, 164, 166, 165, 167, 165, 168, + 165, 169, 165, 165, 165, 170, 170, 170, 170, 171, + 171, 172, 172, 173, 173, 173, 173, 174, 175, 175, + 176, 176, 176, 177, 177, 177, 178, 178, 179, 180, + 181, 181, 182, 182, 182, 183, 184, 184, 185, 185, + 185, 185, 185, 185, 186, 186, 186, 186, 186, 187, + 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, + 188, 189, 190, 190, 191, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 193, 193, + 193, 193, 193, 193, 193, 194, 194, 194, 194, 195, + 196, 198, 197, 199, 199, 199, 199, 200, 200, 200, + 200, 201, 201, 202, 203, 203, 204, 204, 204, 204, + 204, 205, 206, 206, 206, 206, 207, 208, 209, 210, + 210, 210, 210, 210, 211, 211, 212, 212, 212, 213, + 214, 214, 214, 214, 215, 215, 216, 216, 216, 217, + 217, 217, 217, 218, 218, 218, 218, 219, 219, 219, + 219, 220, 220, 220, 221, 221, 221, 221, 221, 222, + 223, 223, 223, 223, 224, 224, 225, 226, 226, 226, + 226, 227, 227, 228, 228, 229, 229, 229, 229, 229, + 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, + 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 231, 231, 232, 232, 232, 233, + 233, 233, 233, 233, 233, 233, 233, 234, 234, 235, + 235, 235, 236, 236, 236, 237, 237, 237, 238, 238, + 238, 238, 238, 238, 238, 238, 239, 239, 239, 239, + 239, 239, 240, 240, 240, 240, 241, 242, 243, 243, + 243, 243, 243, 243, 243, 244, 244, 245, 245, 246, + 246, 246, 246, 246, 246, 247, 247, 247, 247, 247, + 247, 247, 247, 247, 248, 248, 248, 248, 248, 248, + 248, 249, 249, 249, 249, 249, 250, 250, 250, 250, + 250, 250, 250, 251, 251, 251, 251, 251, 251, 251, + 251, 251, 251, 251, 252, 252, 252, 252, 252, 253, + 253, 253, 254, 254, 254, 255, 255, 255, 256, 256, + 256, 257, 257, 257, 258, 258, 258, 258, 258, 259, + 259, 260, 260, 261, 261, 261, 262, 262, 263, 264 }; static const short yyr2[] = { 0, @@ -649,48 +850,48 @@ static const short yyr2[] = { 0, 1, 1, 1, 1, 1, 2, 0, 7, 0, 6, 3, 2, 3, 4, 0, 2, 3, 2, 0, 2, 2, 1, 3, 3, 2, 3, 1, 2, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 4, 1, 3, - 3, 1, 3, 3, 4, 1, 3, 2, 3, 3, - 1, 1, 0, 3, 2, 3, 3, 4, 4, 2, - 3, 2, 3, 2, 3, 4, 3, 3, 3, 1, - 3, 3, 2, 3, 2, 3, 0, 2, 2, 1, - 3, 3, 1, 2, 1, 2, 3, 1, 3, 4, - 4, 5, 3, 4, 2, 3, 3, 4, 4, 5, - 7, 6, 1, 1, 0, 4, 0, 5, 0, 5, - 0, 6, 3, 4, 2, 3, 2, 3, 2, 3, - 1, 2, 1, 1, 1, 1, 1, 2, 2, 2, - 3, 3, 4, 1, 3, 3, 2, 0, 4, 1, - 2, 1, 1, 1, 2, 2, 3, 1, 1, 1, + 1, 1, 1, 2, 1, 1, 1, 3, 4, 1, + 3, 3, 1, 3, 3, 4, 1, 3, 2, 3, + 3, 1, 1, 0, 3, 2, 3, 3, 4, 4, + 2, 3, 2, 3, 2, 3, 4, 3, 3, 3, + 1, 3, 3, 2, 3, 2, 3, 0, 2, 2, + 1, 3, 3, 1, 2, 1, 2, 3, 1, 0, + 3, 2, 3, 3, 4, 2, 3, 3, 4, 4, + 5, 7, 6, 1, 1, 0, 4, 0, 5, 0, + 5, 0, 6, 3, 4, 2, 3, 2, 3, 2, + 3, 1, 2, 1, 1, 1, 1, 1, 2, 2, + 2, 3, 4, 1, 3, 3, 2, 3, 1, 1, + 1, 2, 1, 1, 1, 2, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, - 4, 5, 4, 5, 6, 7, 6, 1, 1, 1, - 1, 1, 1, 1, 5, 2, 3, 4, 7, 7, - 5, 2, 3, 5, 2, 3, 3, 4, 1, 2, - 2, 1, 2, 3, 2, 2, 3, 2, 4, 2, - 2, 3, 4, 2, 1, 7, 7, 6, 3, 5, - 4, 7, 6, 2, 2, 3, 2, 0, 1, 1, - 2, 0, 1, 1, 3, 3, 2, 3, 2, 3, - 2, 3, 2, 3, 2, 3, 2, 3, 3, 2, - 3, 5, 5, 2, 4, 3, 1, 3, 3, 4, - 2, 1, 2, 5, 2, 4, 3, 2, 2, 1, - 1, 1, 1, 3, 1, 1, 1, 1, 3, 3, - 3, 3, 3, 3, 3, 3, 5, 4, 6, 5, - 4, 5, 5, 6, 3, 3, 4, 5, 2, 3, - 3, 3, 1, 3, 3, 3, 3, 4, 4, 4, - 4, 3, 3, 1, 2, 3, 3, 2, 2, 3, - 3, 3, 3, 2, 3, 4, 5, 6, 5, 6, - 4, 4, 4, 4, 3, 4, 3, 4, 1, 1, - 1, 1, 2, 2, 1, 1, 2, 2, 1, 2, - 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, - 2, 5, 4, 4, 5, 4, 2, 5, 4, 5, - 1, 3, 3, 3, 3, 3, 3, 1, 3, 3, - 3, 3, 1, 3, 3, 3, 3, 3, 3, 1, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 1, 3, 3, 3, 3, 1, 3, 3, 1, 3, - 3, 1, 3, 3, 1, 3, 3, 1, 3, 3, - 1, 5, 4, 3, 5, 1, 1, 3, 3, 1, - 1, 1, 1, 1, 1, 1 + 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, + 4, 4, 5, 4, 5, 6, 7, 6, 1, 1, + 1, 1, 1, 1, 1, 5, 2, 3, 4, 7, + 7, 0, 3, 4, 2, 3, 5, 2, 3, 3, + 4, 1, 2, 2, 1, 2, 3, 2, 2, 3, + 2, 4, 2, 2, 3, 4, 2, 1, 7, 7, + 6, 3, 5, 4, 7, 6, 2, 2, 3, 2, + 0, 1, 1, 2, 0, 1, 1, 3, 3, 2, + 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, + 3, 3, 2, 3, 5, 5, 2, 4, 3, 1, + 3, 3, 4, 2, 1, 2, 2, 4, 2, 3, + 4, 2, 2, 1, 1, 1, 1, 3, 1, 1, + 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, + 5, 4, 6, 5, 4, 5, 5, 6, 3, 3, + 4, 5, 2, 3, 3, 3, 1, 3, 3, 3, + 3, 4, 4, 4, 4, 3, 3, 1, 2, 3, + 3, 2, 2, 3, 3, 3, 3, 2, 3, 4, + 5, 6, 5, 6, 4, 4, 4, 4, 3, 4, + 3, 4, 1, 1, 1, 1, 2, 2, 1, 1, + 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, + 2, 2, 1, 2, 2, 5, 4, 4, 5, 4, + 2, 5, 4, 5, 1, 3, 3, 3, 3, 3, + 3, 1, 3, 3, 3, 3, 1, 3, 3, 3, + 3, 3, 3, 1, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 1, 3, 3, 3, 3, 1, + 3, 3, 1, 3, 3, 1, 3, 3, 1, 3, + 3, 1, 3, 3, 1, 5, 4, 3, 5, 1, + 1, 3, 3, 1, 1, 1, 1, 1, 1, 1 }; static const short yydefact[] = { 0, @@ -698,1053 +899,1023 @@ static const short yydefact[] = { 0, 0, 36, 43, 44, 38, 0, 51, 52, 46, 27, 0, 23, 24, 25, 0, 62, 0, 41, 0, 0, 37, 39, 0, 0, 56, 0, 0, 47, 45, 0, - 163, 0, 0, 159, 63, 0, 69, 42, 40, 0, - 0, 0, 61, 0, 49, 0, 26, 167, 17, 165, - 15, 0, 156, 0, 0, 68, 16, 0, 0, 59, - 164, 0, 161, 64, 69, 50, 48, 12, 0, 10, - 11, 169, 0, 8, 9, 13, 14, 15, 0, 175, - 177, 0, 176, 0, 171, 173, 174, 168, 166, 160, - 67, 71, 72, 70, 0, 158, 0, 57, 112, 0, - 127, 110, 0, 0, 89, 92, 127, 0, 0, 0, - 114, 0, 0, 179, 178, 170, 172, 0, 0, 60, - 162, 0, 0, 0, 0, 107, 98, 87, 0, 0, - 0, 0, 106, 21, 18, 22, 20, 19, 113, 127, - 111, 0, 127, 74, 73, 55, 188, 75, 23, 0, - 85, 0, 77, 79, 83, 84, 0, 80, 0, 81, - 127, 86, 82, 58, 118, 115, 0, 0, 0, 120, - 129, 130, 128, 119, 117, 91, 0, 90, 94, 0, - 0, 0, 0, 0, 0, 0, 333, 0, 0, 0, - 0, 6, 5, 2, 3, 4, 7, 332, 0, 400, - 0, 102, 399, 330, 335, 0, 331, 336, 337, 338, - 416, 401, 402, 431, 405, 406, 409, 419, 438, 443, - 450, 461, 466, 469, 472, 475, 478, 481, 486, 495, - 487, 0, 101, 99, 97, 100, 109, 88, 108, 187, - 0, 0, 127, 76, 78, 105, 0, 136, 0, 125, - 123, 0, 116, 0, 0, 410, 400, 336, 338, 407, - 411, 408, 415, 414, 413, 412, 0, 384, 0, 0, - 0, 16, 0, 420, 417, 421, 418, 427, 0, 400, - 0, 180, 0, 184, 0, 0, 0, 0, 0, 95, - 0, 0, 359, 0, 404, 403, 0, 0, 0, 0, + 164, 0, 0, 160, 63, 0, 69, 42, 40, 0, + 0, 0, 61, 0, 49, 0, 26, 168, 17, 166, + 15, 0, 157, 0, 0, 68, 16, 0, 0, 59, + 165, 0, 162, 64, 69, 50, 48, 12, 0, 10, + 11, 170, 0, 8, 9, 13, 14, 15, 0, 176, + 178, 0, 177, 0, 172, 174, 175, 169, 167, 161, + 67, 71, 72, 70, 0, 159, 0, 57, 113, 0, + 128, 111, 0, 0, 90, 93, 128, 0, 0, 0, + 115, 0, 0, 180, 179, 171, 173, 0, 0, 60, + 163, 0, 0, 0, 0, 108, 99, 88, 0, 0, + 0, 0, 107, 21, 18, 22, 20, 19, 114, 128, + 112, 0, 128, 74, 73, 55, 189, 75, 23, 0, + 86, 0, 77, 79, 83, 85, 0, 80, 0, 81, + 140, 128, 87, 82, 0, 58, 119, 116, 0, 0, + 0, 121, 130, 131, 129, 120, 118, 92, 0, 91, + 95, 0, 0, 0, 0, 0, 0, 0, 337, 0, + 0, 0, 0, 6, 5, 2, 3, 4, 7, 336, + 0, 404, 0, 103, 403, 334, 339, 0, 335, 340, + 341, 342, 420, 405, 406, 435, 409, 410, 413, 423, + 442, 447, 454, 465, 470, 473, 476, 479, 482, 485, + 490, 499, 491, 0, 102, 100, 98, 101, 110, 89, + 109, 187, 0, 128, 76, 78, 84, 106, 0, 137, + 0, 142, 0, 55, 0, 0, 278, 0, 0, 0, + 0, 0, 0, 0, 0, 337, 0, 221, 0, 8, + 404, 0, 0, 195, 0, 210, 0, 191, 193, 0, + 194, 199, 211, 0, 200, 212, 0, 201, 202, 213, + 252, 0, 203, 0, 214, 204, 291, 0, 215, 216, + 217, 219, 218, 0, 220, 245, 244, 0, 242, 243, + 240, 241, 239, 126, 124, 0, 117, 0, 0, 414, + 404, 340, 342, 411, 415, 412, 419, 418, 417, 416, + 0, 388, 0, 0, 0, 16, 0, 424, 421, 425, + 422, 431, 0, 404, 0, 181, 184, 0, 0, 0, + 0, 0, 96, 0, 0, 363, 0, 408, 407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 493, 494, 0, - 0, 55, 0, 0, 275, 0, 0, 0, 0, 0, - 0, 0, 0, 333, 0, 220, 0, 8, 400, 0, - 0, 194, 0, 209, 0, 190, 192, 0, 193, 198, - 210, 0, 199, 211, 0, 200, 201, 212, 0, 202, - 0, 213, 203, 288, 0, 214, 215, 216, 218, 217, - 0, 219, 244, 243, 0, 241, 242, 239, 240, 238, - 143, 0, 0, 135, 104, 133, 137, 0, 139, 126, - 124, 122, 121, 132, 131, 346, 341, 0, 383, 373, - 372, 355, 0, 366, 374, 0, 367, 0, 356, 0, - 0, 0, 0, 0, 0, 343, 334, 182, 181, 0, - 345, 340, 385, 0, 363, 395, 0, 344, 339, 361, - 342, 362, 382, 397, 0, 360, 0, 435, 432, 436, - 433, 437, 434, 441, 439, 442, 440, 447, 444, 448, - 445, 449, 446, 457, 452, 459, 454, 456, 451, 458, - 453, 460, 0, 455, 464, 462, 465, 463, 468, 467, - 471, 470, 474, 473, 477, 476, 480, 479, 484, 0, - 0, 489, 488, 227, 228, 226, 246, 0, 310, 0, - 299, 297, 0, 307, 305, 0, 271, 0, 252, 0, - 321, 0, 285, 0, 303, 301, 0, 0, 196, 0, - 0, 223, 221, 0, 0, 189, 191, 195, 317, 400, - 222, 225, 270, 0, 400, 0, 290, 294, 287, 0, - 0, 314, 0, 144, 140, 134, 145, 400, 0, 0, - 0, 141, 391, 392, 0, 378, 379, 0, 375, 368, - 0, 371, 369, 370, 357, 348, 0, 429, 423, 426, - 0, 0, 424, 186, 183, 185, 386, 0, 396, 393, - 0, 398, 394, 351, 0, 483, 0, 247, 0, 311, - 309, 300, 298, 308, 306, 272, 0, 253, 0, 0, - 0, 318, 322, 319, 286, 304, 302, 334, 0, 197, - 229, 0, 0, 0, 291, 0, 279, 0, 0, 316, - 0, 142, 0, 146, 0, 0, 147, 389, 0, 377, - 376, 381, 380, 350, 358, 347, 428, 422, 430, 425, - 365, 364, 387, 0, 352, 353, 485, 482, 248, 0, - 273, 269, 0, 325, 0, 329, 328, 323, 320, 233, - 0, 230, 231, 0, 0, 296, 295, 281, 0, 293, - 0, 315, 0, 0, 148, 0, 0, 390, 349, 388, - 354, 0, 245, 0, 198, 0, 205, 206, 0, 207, - 208, 0, 254, 0, 251, 327, 0, 234, 0, 0, - 232, 0, 0, 280, 0, 313, 312, 0, 149, 0, - 0, 0, 224, 274, 0, 0, 0, 255, 0, 259, - 0, 262, 326, 0, 237, 235, 0, 0, 278, 0, - 0, 0, 150, 0, 249, 0, 0, 268, 265, 266, - 496, 0, 257, 260, 0, 256, 0, 263, 324, 236, - 276, 277, 152, 0, 0, 0, 0, 267, 264, 258, - 151, 0, 0, 0, 0, 283, 0, 250, 282, 0, - 0, 0 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 497, 498, 0, 144, 0, 143, 136, 105, 134, 138, + 189, 141, 0, 228, 229, 227, 247, 0, 313, 0, + 302, 300, 0, 310, 308, 0, 274, 0, 255, 0, + 324, 0, 288, 0, 306, 304, 0, 0, 197, 0, + 0, 224, 222, 0, 0, 190, 188, 192, 196, 320, + 404, 223, 226, 0, 273, 0, 404, 0, 293, 297, + 290, 0, 0, 317, 0, 127, 125, 123, 122, 133, + 132, 350, 345, 0, 387, 377, 376, 359, 0, 370, + 378, 0, 371, 0, 360, 0, 0, 0, 0, 0, + 0, 347, 338, 182, 0, 349, 344, 389, 0, 367, + 399, 0, 348, 343, 365, 346, 366, 386, 401, 0, + 364, 0, 439, 436, 440, 437, 441, 438, 445, 443, + 446, 444, 451, 448, 452, 449, 453, 450, 461, 456, + 463, 458, 460, 455, 462, 457, 464, 0, 459, 468, + 466, 469, 467, 472, 471, 475, 474, 478, 477, 481, + 480, 484, 483, 488, 0, 0, 493, 492, 145, 135, + 404, 0, 0, 146, 0, 248, 0, 314, 312, 303, + 301, 311, 309, 275, 0, 256, 0, 0, 0, 321, + 325, 0, 322, 289, 307, 305, 338, 0, 198, 230, + 0, 0, 0, 253, 0, 294, 0, 282, 0, 0, + 319, 0, 395, 396, 0, 382, 383, 0, 379, 372, + 0, 375, 373, 374, 361, 352, 0, 433, 427, 430, + 0, 0, 428, 186, 183, 185, 390, 0, 400, 397, + 0, 402, 398, 355, 0, 487, 0, 0, 147, 0, + 0, 148, 249, 0, 276, 272, 0, 329, 0, 333, + 332, 326, 323, 327, 234, 0, 231, 232, 0, 0, + 0, 258, 0, 262, 0, 265, 0, 299, 298, 284, + 0, 296, 0, 318, 0, 393, 0, 381, 380, 385, + 384, 354, 362, 351, 432, 426, 434, 429, 369, 368, + 391, 0, 356, 357, 489, 486, 0, 149, 0, 0, + 0, 246, 0, 199, 0, 206, 207, 0, 208, 209, + 0, 257, 330, 0, 235, 0, 0, 233, 271, 268, + 269, 500, 0, 260, 263, 0, 259, 0, 266, 0, + 0, 283, 0, 316, 315, 394, 353, 392, 358, 0, + 150, 0, 0, 0, 225, 277, 0, 331, 328, 238, + 236, 0, 270, 267, 261, 0, 281, 0, 0, 0, + 151, 0, 250, 0, 0, 237, 279, 280, 153, 0, + 0, 0, 0, 152, 0, 0, 0, 0, 286, 0, + 251, 285, 0, 0, 0 }; -static const short yydefgoto[] = { 770, - 208, 347, 209, 85, 86, 68, 60, 87, 210, 22, +static const short yydefgoto[] = { 773, + 210, 279, 211, 85, 86, 68, 60, 87, 212, 22, 23, 24, 8, 9, 10, 11, 12, 13, 14, 15, - 351, 352, 132, 105, 47, 70, 104, 130, 162, 163, - 164, 91, 114, 115, 116, 211, 166, 257, 92, 111, - 179, 180, 136, 183, 395, 168, 169, 170, 171, 399, - 549, 353, 18, 43, 72, 65, 107, 44, 63, 94, - 95, 96, 97, 212, 295, 354, 251, 747, 356, 357, - 358, 359, 684, 360, 361, 362, 363, 687, 364, 365, - 366, 367, 688, 368, 695, 719, 720, 721, 722, 369, - 370, 690, 371, 372, 373, 691, 374, 375, 539, 669, - 670, 376, 377, 378, 379, 380, 381, 382, 602, 603, - 604, 213, 214, 215, 216, 434, 217, 414, 415, 416, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 330, 435, 742 + 283, 284, 132, 105, 47, 70, 104, 130, 162, 163, + 164, 91, 114, 115, 116, 213, 166, 259, 92, 111, + 181, 182, 136, 185, 398, 168, 169, 170, 261, 171, + 172, 402, 552, 285, 18, 43, 72, 65, 107, 44, + 63, 94, 95, 96, 97, 214, 358, 286, 175, 437, + 718, 288, 289, 290, 291, 693, 292, 293, 294, 295, + 696, 296, 297, 298, 299, 697, 300, 444, 301, 584, + 653, 654, 655, 656, 302, 303, 699, 304, 305, 306, + 700, 307, 308, 451, 661, 662, 309, 310, 311, 312, + 313, 314, 315, 570, 571, 572, 573, 215, 216, 217, + 218, 489, 219, 470, 471, 472, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 393, 490, 713 }; -static const short yypact[] = { 353, --32768,-32768, 325, -41, 376, 398,-32768,-32768, 164, 528, - 436,-32768,-32768,-32768,-32768, 494,-32768,-32768,-32768,-32768, - 10,-32768,-32768,-32768, 18,-32768, 297,-32768, 11, 576, --32768,-32768, 445, 598,-32768, -41, 428,-32768,-32768, 690, --32768, 470, -13, -46,-32768, 495, 82,-32768,-32768, -41, - 612, 328,-32768, 381,-32768, 28,-32768,-32768,-32768,-32768, - -36, 1021,-32768, 531, -13,-32768,-32768, 232, 577,-32768, --32768, -13, -46,-32768, 82,-32768,-32768,-32768, 590,-32768, --32768,-32768, 592, 2,-32768,-32768, 170, -7, 916,-32768, --32768, 92,-32768, 1055,-32768,-32768,-32768,-32768,-32768,-32768, --32768,-32768,-32768, 172, 202,-32768, -13,-32768,-32768, 262, - -1,-32768, 424, -75,-32768, 504, -1, 9, 86, 278, --32768, 615, 617,-32768,-32768,-32768,-32768, 637, 936,-32768, --32768, 202, 729, 653, 117,-32768,-32768,-32768, 660, 2333, - 132, 384,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -1, --32768, 655, -1,-32768,-32768, 337, 377,-32768, 417, 916, --32768, 1001,-32768,-32768,-32768,-32768, 47,-32768, 406,-32768, - 472,-32768,-32768,-32768,-32768,-32768, 667, 903, 551,-32768, --32768,-32768, 442,-32768,-32768,-32768, 460,-32768,-32768, 3080, - 3145, 3196, 3261, 466, 21, 497,-32768, 3312, 3377, 3428, - 5442,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 543, 915, - 99,-32768, 548, 560,-32768, 712,-32768, 770,-32768, 836, - 888,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 619, 945, - 1019, 937, 935, 669, 676, 694, 714, 258,-32768,-32768, --32768, 872,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - 2125, 731, 472,-32768,-32768,-32768, 128, 634, 668,-32768, - 873, 719,-32768, 585, 721,-32768, 673,-32768,-32768,-32768, --32768,-32768,-32768,-32768,-32768,-32768, 25,-32768, 724, 992, - 643, 643, 290,-32768,-32768,-32768,-32768,-32768, 746, 962, - 208,-32768, 654,-32768, 358, 331, 5509, 3493, 622,-32768, - 427, 3544,-32768, 393,-32768,-32768, 3609, 3660, 3725, 3776, - 3841, 3892, 3957, 4008, 4073, 4124, 4189, 4240, 525, 4305, - 4356, 4421, 4472, 4537, 4588, 4653, 2384,-32768,-32768, 4704, - 510, 415, 416, 4769,-32768, 182, 2449, 13, 418, 426, - 26, 450, 204, 679, 5741,-32768, -41, 618, 844, 448, - 827,-32768, 684,-32768, 1785,-32768,-32768, 685,-32768,-32768, --32768, 2193,-32768,-32768, 689,-32768,-32768,-32768, 2193,-32768, - 2193,-32768,-32768, 5792, 697,-32768,-32768,-32768,-32768,-32768, - 469,-32768, 702, 711, 888, 947, 965,-32768,-32768,-32768, --32768, 759, 668,-32768,-32768, 728,-32768, 1853, 732,-32768, - 873,-32768,-32768,-32768,-32768,-32768,-32768, 123, 740,-32768, --32768,-32768, 2500, 643,-32768, 493, 643, 493,-32768, 2565, - 4820, 166, -30, 2616, 308,-32768, 1180,-32768,-32768, 1645, --32768,-32768,-32768, 781,-32768,-32768, 239,-32768,-32768,-32768, --32768,-32768, 772,-32768, 244,-32768, 5560,-32768,-32768,-32768, --32768,-32768,-32768,-32768, 619,-32768, 619,-32768, 945,-32768, - 945,-32768, 945,-32768, 1019,-32768, 1019,-32768, 1019,-32768, - 1019,-32768, 2,-32768,-32768, 937,-32768, 937,-32768, 935, --32768, 669,-32768, 676,-32768, 694,-32768, 714,-32768, 766, - 784,-32768,-32768,-32768,-32768,-32768,-32768, 4885,-32768, 143, --32768,-32768, 153,-32768,-32768, 180,-32768, 4936,-32768, 5001, --32768, 681,-32768, 5350,-32768,-32768, 235, 242, 783, 2681, - 620,-32768,-32768, -41, 2732,-32768,-32768,-32768,-32768, 1070, --32768,-32768,-32768, 821, 984, 903,-32768,-32768,-32768, 104, - 2797,-32768, 5052,-32768, 802,-32768,-32768, 1037, 1921, 812, - 1989,-32768,-32768,-32768, 5625,-32768,-32768, 259,-32768, 826, - 295,-32768, 826,-32768,-32768, 202, 61,-32768,-32768,-32768, - 5117, 817,-32768,-32768,-32768,-32768,-32768, 5168,-32768,-32768, - 5676,-32768,-32768, 202, 785,-32768, 5233,-32768, 252,-32768, --32768,-32768,-32768,-32768,-32768,-32768, 253,-32768, 845, 471, - 46, 681,-32768,-32768,-32768,-32768,-32768,-32768, 473, 783, --32768, 941, 122, 851,-32768, 5484,-32768, 5375, 855, 865, - 867,-32768, 645,-32768, 2057, 2848,-32768,-32768, 792,-32768, --32768,-32768,-32768,-32768,-32768, 202,-32768,-32768,-32768,-32768, --32768,-32768,-32768, 814,-32768, 202,-32768,-32768,-32768, 2259, --32768,-32768, 87,-32768, 788,-32768,-32768,-32768,-32768,-32768, - 2913,-32768,-32768, 972, 5741,-32768,-32768,-32768, 885, 884, - 5417,-32768, 206, 478,-32768, 245, 134,-32768,-32768,-32768, --32768, 481,-32768, 931, 934, 2259,-32768,-32768, 2259,-32768, --32768, 897,-32768, 733,-32768, 905, 910,-32768, 1016, 138, --32768, 929, 2193,-32768, 939,-32768,-32768, 2964,-32768, 257, - 4885, 2193,-32768,-32768, 3029, 167, 5284,-32768, 739,-32768, - 1484,-32768,-32768, 406,-32768,-32768, 1024, 944,-32768, 2193, - 273, 150,-32768, 269,-32768, 5375, 948,-32768,-32768,-32768, --32768, 212,-32768,-32768, 1571,-32768, 1717,-32768,-32768,-32768, --32768,-32768,-32768, 276, 2259, 946, 5417,-32768,-32768,-32768, --32768, 974, 2259, 955, 2259,-32768, 2259,-32768,-32768, 1038, - 1052,-32768 +static const short yypact[] = { 538, +-32768,-32768, 61, -61, 310, 456,-32768,-32768, 245, 513, + 578,-32768,-32768,-32768,-32768, 567,-32768,-32768,-32768,-32768, + 19,-32768,-32768,-32768, 160,-32768, 296,-32768, 33, 603, +-32768,-32768, 680, 629,-32768, -61, 486,-32768,-32768, 503, +-32768, 504, -50, -27,-32768, 510, 130,-32768,-32768, -61, + 693, 338,-32768, 356,-32768, 37,-32768,-32768,-32768,-32768, + -2, 830,-32768, 520, -50,-32768,-32768, 342, 521,-32768, +-32768, -50, -27,-32768, 130,-32768,-32768,-32768, 530,-32768, +-32768,-32768, 539, 156,-32768,-32768, 197, -55, 787,-32768, +-32768, 53,-32768, 988,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 236, 132,-32768, -50,-32768,-32768, 371, + 379,-32768, 122, 550,-32768, 716, 379, 43, 77, 260, +-32768, 562, 565,-32768,-32768,-32768,-32768, 568, 869,-32768, +-32768, 132, 421, 574, 95,-32768,-32768,-32768, 580, 1258, + 113, 478,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 379, +-32768, 759, 379,-32768,-32768, 523, 519,-32768, 548, 787, +-32768, 1021,-32768,-32768, 576,-32768, 203,-32768, 602,-32768, +-32768, 625,-32768,-32768, 1818,-32768,-32768,-32768, 582, 948, + -29,-32768,-32768,-32768, 588,-32768,-32768,-32768, 350,-32768, +-32768, 2787, 2838, 2903, 2954, 609, 28, 700,-32768, 3019, + 3070, 3135, 5134,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 632, 949, 66,-32768, 642, 656,-32768, 583,-32768, 437, +-32768, 771, 831,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 887, 895, 950, 1007, 889, 745, 762, 758, 777, 268, +-32768,-32768,-32768, 819,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 896, 625,-32768,-32768,-32768,-32768, 671, 712, + 704,-32768, 502, 114, 306, 3186,-32768, 263, 2091, 47, + 391, 416, 232, 423, 307, 723, 5433,-32768, -61, 733, + 1018, 319, 918,-32768, 728,-32768, 1750,-32768,-32768, 725, +-32768,-32768,-32768, 1886,-32768,-32768, 788,-32768,-32768,-32768, +-32768, 1886,-32768, 1886,-32768,-32768, 5484, 791,-32768,-32768, +-32768,-32768,-32768, 426,-32768, 706, 782, 831, 892, 897, +-32768,-32768,-32768,-32768, 850, 590,-32768, 711, 593,-32768, + 545,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 31,-32768, 622, 908, 739, 739, 430,-32768,-32768,-32768, +-32768,-32768, 683, 998, 86,-32768,-32768, 694, 468, 5201, + 3251, 30,-32768, 474, 3302,-32768, 458,-32768,-32768, 3367, + 3418, 3483, 3534, 3599, 3650, 3715, 3766, 3831, 3882, 3947, + 3998, 719, 4063, 4114, 4179, 4230, 4295, 4346, 4411, 2142, +-32768,-32768, 4462,-32768, 188,-32768,-32768,-32768, 797,-32768, +-32768,-32768, 1750,-32768,-32768,-32768,-32768, 4527,-32768, 59, +-32768,-32768, 74,-32768,-32768, 127,-32768, 4578,-32768, 4643, +-32768, 796,-32768, 5042,-32768,-32768, 217, 295, 744, 2207, + 775,-32768,-32768, -61, 2258,-32768,-32768,-32768,-32768,-32768, + 1087,-32768,-32768, 754,-32768, 804, 1038, 948,-32768,-32768, +-32768, 69, 2323,-32768, 4694,-32768, 850,-32768,-32768,-32768, +-32768,-32768,-32768, 494, 808,-32768,-32768,-32768, 2374, 739, +-32768, 490, 739, 490,-32768, 2439, 4759, 224, 359, 2490, + 450,-32768, 1509,-32768, 2026,-32768,-32768,-32768, 617,-32768, +-32768, 234,-32768,-32768,-32768,-32768,-32768, 810,-32768, 248, +-32768, 5252,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 887, +-32768, 887,-32768, 895,-32768, 895,-32768, 895,-32768, 950, +-32768, 950,-32768, 950,-32768, 950,-32768, 156,-32768,-32768, + 1007,-32768, 1007,-32768, 889,-32768, 745,-32768, 762,-32768, + 758,-32768, 777,-32768, 880, 820,-32768,-32768,-32768,-32768, + 1076, 1750, 827,-32768, 1750,-32768, 352,-32768,-32768,-32768, +-32768,-32768,-32768,-32768, 438,-32768, 829, 461, 309, 796, +-32768, 602,-32768,-32768,-32768,-32768,-32768, 469, 744,-32768, + 928, 94, 185,-32768, 838,-32768, 5176,-32768, 5067, 834, + 851, 856,-32768,-32768, 5317,-32768,-32768, 262,-32768, 859, + 265,-32768, 859,-32768,-32768, 132, 102,-32768,-32768,-32768, + 4810, 1388,-32768,-32768,-32768,-32768,-32768, 4875,-32768,-32768, + 5368,-32768,-32768, 132, 627,-32768, 4926, 799,-32768, 1750, + 2555,-32768,-32768, 1952,-32768,-32768, 396,-32768, 737,-32768, +-32768,-32768,-32768,-32768,-32768, 2606,-32768,-32768, 952, 355, + 4991,-32768, 190,-32768, 1484,-32768, 5433,-32768,-32768,-32768, + 867, 863, 5109,-32768, 402,-32768, 648,-32768,-32768,-32768, +-32768,-32768,-32768, 132,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 726,-32768, 132,-32768,-32768, 471,-32768, 239, 116, + 477,-32768, 910, 920, 1952,-32768,-32768, 1952,-32768,-32768, + 884,-32768, 893, 901,-32768, 995, 142,-32768,-32768,-32768, +-32768,-32768, 424,-32768,-32768, 1614,-32768, 1682,-32768, 905, + 1886,-32768, 907,-32768,-32768,-32768,-32768,-32768,-32768, 2671, +-32768, 242, 4527, 1886,-32768,-32768, 2722,-32768,-32768,-32768, +-32768, 1008,-32768,-32768,-32768, 917,-32768, 1886, 289, 177, +-32768, 439,-32768, 5067, 919,-32768,-32768,-32768,-32768, 291, + 1952, 925, 5109,-32768, 965, 1952, 942, 1952,-32768, 1952, +-32768,-32768, 1039, 1045,-32768 }; static const short yypgoto[] = {-32768, --32768, -58, 14, 737, 4, -99, 674,-32768, -3, 677, --32768, 79,-32768, 1047, 760,-32768, 266,-32768,-32768, 881, - 7, 23,-32768,-32768, 1007, 997,-32768, -131,-32768, 912, --32768, 281, -121, 928, 431, -195,-32768,-32768, 408, 509, - 832, -259, -73,-32768,-32768,-32768,-32768,-32768, 918, 686, --32768, 700, -34,-32768,-32768,-32768,-32768, 1040, 508,-32768, - 1006,-32768,-32768, 500,-32768, -120,-32768, -221, -340,-32768, - 727, -299, 101, -526,-32768, -325,-32768,-32768,-32768, -336, --32768,-32768,-32768,-32768,-32768,-32768, 389, 391, -666, -300, --32768,-32768,-32768,-32768,-32768,-32768,-32768, -280,-32768, -297, - 741,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 511, - 517,-32768,-32768, -31,-32768, -369,-32768, 813, 219, -269, - 1157, 133, 1187, 279, 423, 486, -20, 569, 607, -419, --32768, 703, 819, 534, 699, 799, 801, 803, 800, 816, --32768, 552, 815, 695,-32768,-32768, -51,-32768 +-32768, -25, -53, 666, -34, -121, 645,-32768, -3, 597, +-32768, 134,-32768, 1040, 806,-32768, 449,-32768,-32768, 689, + 17, 610,-32768,-32768, 999, 981,-32768, -131,-32768, 904, +-32768, -57, -117, 924, -163, -192,-32768,-32768, 305, -65, + 805, -321, -98,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 909,-32768,-32768, 664, -41,-32768,-32768,-32768,-32768, 1016, + 429,-32768, 983,-32768,-32768, 393,-32768, -106, 818, -401, + -165, -283,-32768, 774, -280, -36, -585,-32768, -492,-32768, +-32768,-32768, -302,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 432, 434, -615, -447,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, -433,-32768, -630, 785,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768, 524,-32768, 532,-32768,-32768, -63, +-32768, -316,-32768, 747, 103, -261, 1023, 223, 1044, 254, + 380, 442, -111, 531, 620, -468,-32768, 600, 636, 681, + 596, 715, 722, 734, 724, 736,-32768, 495, 720, 750, +-32768,-32768, 65,-32768 }; -#define YYLAST 5901 +#define YYLAST 5593 static const short yytable[] = { 21, - 174, 152, 29, 83, 403, 294, 16, 573, 173, 144, - 38, 48, 418, 278, 527, 16, 16, 16, 41, 423, - 425, 278, 17, 138, 139, 406, 511, 93, 76, 355, - 123, 17, 17, 17, 182, 83, 16, 538, 61, 16, - 16, 173, 61, 143, 20, 59, 656, 256, 258, 67, - 567, 134, 17, 64, 748, 17, 17, 16, 88, 93, - 61, 635, 531, 571, 50, 61, 561, 59, 89, 533, - 83, 534, 59, 17, 177, 84, 247, 585, 748, 249, - 42, 62, 25, 27, 90, 88, 146, 693, 243, 120, - 88, 407, 124, 50, 172, 135, 283, 259, 118, 300, - 89, 123, 84, 83, 615, -154, 145, 84, 39, 49, - 40, 50, -155, 279, 52, 54, 90, 184, 57, 262, - 157, 279, 663, 685, 61, 88, 77, 172, 57, 88, - 61, 59, 244, 69, 663, 160, 396, 67, 726, 178, - 157, -103, 84, 590, 560, -103, 84, 563, 291, 243, - 726, 161, 640, 592, 636, 613, 88, 110, 88, 685, - 578, 113, 685, -30, 1, 405, 570, 738, 160, 270, - 272, 274, 276, 84, 88, 84, 551, 285, 287, 393, - 594, 694, 501, 147, 161, 629, 267, 267, 267, 267, - 125, 84, 61, 177, 267, 267, 290, -93, -93, 282, - 110, 113, -289, 616, 515, 177, 706, 2, 426, 281, - 527, 644, 758, 289, 185, 664, 553, 187, 3, 383, - 512, 578, 157, 554, 4, 519, 394, 710, 685, 245, - 5, 727, 101, 578, 576, 606, 685, 578, 685, 579, - 685, 591, 426, 754, 582, 662, 437, 349, 88, 578, - 445, 593, 649, 651, 739, 187, 677, 701, 178, 630, - 88, 61, 7, 557, 348, 84, 119, 20, 67, 649, - 178, 128, 326, 725, 31, 491, 750, 84, 595, 667, - 502, 538, 500, -66, 527, 506, 449, 451, 453, 20, - 419, 700, 524, 518, 304, 632, 129, 45, 31, 759, - 157, 427, 516, 267, 267, 267, 267, 267, 267, 267, - 267, 267, 267, 267, 267, 88, 267, 267, 267, 267, - 267, 267, 267, 383, 686, 19, -66, 625, 71, 350, - 383, 431, 473, 607, 538, 608, 580, 383, 732, 383, - 187, 583, 383, 709, 327, 650, 652, 88, -65, 689, - 683, 349, -28, 1, 133, 733, 631, 409, 530, 46, - 686, 558, 755, 686, 84, 530, 383, 530, 348, 692, - 535, 753, 437, 705, 761, 148, 26, 57, 243, 443, - 536, 74, 420, 384, 246, 689, 531, 348, 689, 533, - 42, -65, 633, 446, 548, 697, 2, 432, 28, 538, - 569, 572, 610, 729, 561, 692, 527, 3, 692, 165, - 20, 348, 735, 4, 503, -317, 497, 267, 507, 5, - 538, 517, -157, 267, 137, 187, 509, 6, 53, 686, - 752, -138, -65, 350, 634, -29, 1, 686, 756, 686, - 350, 686, 165, 46, -32, 1, 589, 350, 522, 350, - 513, 7, 645, 429, 689, 683, 597, 430, 599, 764, - 137, 20, 689, 729, 689, 735, 689, 752, 437, 542, - 58, 654, 250, 660, 692, -65, 350, 524, 660, 2, - 657, 497, 692, 20, 692, 447, 692, 384, 2, 619, - 3, 621, -25, -25, 384, 66, 4, 280, 442, 3, - 157, 384, 5, 384, 679, 4, 384, -317, 498, 252, - 508, 5, 20, 20, 681, -96, 133, 383, 510, 383, - -96, -96, -96, -96, 134, 472, 642, -31, 1, 385, - 384, 98, 88, -25, 7, 523, 167, 35, -25, -25, - -25, 265, 514, 7, -25, 349, 78, 349, -25, 84, - 638, -96, 707, -96, 36, 20, -96, -96, -96, -96, - 37, 543, 348, 655, 348, 661, 277, 267, 267, 167, - 708, 2, 100, 711, 78, -34, 1, 102, 80, 106, - 20, 81, 20, 267, 383, 402, 383, 201, 4, 561, - 109, 117, 112, 383, 5, 140, 177, -33, 1, 57, - 141, 142, 187, 749, 494, 495, 80, 261, 496, 81, - 20, -35, 1, 702, 131, 149, 20, 151, 383, 2, - 438, 349, 438, 307, 308, 309, 7, 350, 2, 350, - 150, 153, 559, 385, 78, 559, 4, 154, 348, 383, - 385, 2, 5, 296, 263, 438, 530, 385, 301, 385, - 264, 88, 385, 181, 383, 2, 302, 383, 4, 734, - 186, 178, 20, 737, 5, 741, 80, 260, 84, 81, - 20, 383, 4, 386, 7, 20, 385, 20, 5, 322, - 383, 384, 530, 384, 609, 530, 439, 323, 439, 383, - 55, 440, 401, 440, 56, 441, 7, 441, 383, 530, - 20, 57, 20, 350, 383, 20, 324, 20, 530, 674, - 7, 439, 303, 383, 118, 383, 440, 349, 296, 400, - 441, 404, 20, 383, 408, 383, 530, 325, 350, 175, - 20, 383, 397, 383, 348, 383, 387, 99, 20, 413, - 600, 349, 103, 349, 601, 20, -335, -335, 384, 428, - 384, 530, 20, 248, 139, -337, -337, 384, 348, 530, - 348, 530, 398, 530, 350, 297, 586, 350, 30, 298, - 34, -153, 2, 299, 2, 20, 525, 386, 78, 716, - 78, 350, 384, 528, 386, 716, 713, 532, 696, 714, - 350, 386, 51, 386, 717, 541, 386, 20, -335, 350, - 717, 155, -335, 384, 20, 159, 20, -337, 350, 20, - 80, -337, 80, 81, 20, 81, 20, 639, 384, 388, - 386, 384, 176, 350, 391, 350, 546, 385, 718, 385, - 552, 2, 555, 350, 743, 384, 159, 78, 159, 421, - 387, 350, 422, 350, 384, 350, 296, 387, 465, 467, - 469, 471, 544, 384, 387, 762, 387, 389, 264, 387, - -491, -491, 384, 766, 581, 768, 78, 769, 384, 80, - 35, 587, 81, 20, 577, 194, 78, 384, 646, 384, - 578, 195, 139, 387, 578, 678, 614, 384, 196, 384, - 32, 578, 197, 37, 385, 384, 385, 384, 80, 384, - 622, 81, 20, 385, 626, 198, 199, 680, 80, 200, - 32, 81, 20, 578, 32, 562, 121, 564, 202, 203, - 204, 205, 561, 388, 206, 207, -492, -492, 385, -15, - 388, 32, 305, 306, -490, -490, 297, 388, 653, 388, - 520, 662, 388, 665, 521, 390, 35, 310, 311, 385, - 320, 321, 78, 671, 315, 316, 317, 318, 672, 35, - 673, 389, 328, 329, 385, 78, 388, 385, 389, 141, - 142, 386, 701, 386, 122, 389, 36, 389, 703, 156, - 389, 385, 37, 616, 80, 78, 712, 81, 20, -204, - 385, -401, -401, 319, 79, 715, 4, 80, 723, 385, - 81, 20, 5, 724, 389, -490, -490, 297, 385, -402, - -402, 298, 455, 457, 385, 299, 725, 80, 476, 478, - 81, 20, 728, 385, 750, 385, 312, 313, 314, 765, - 157, 158, 730, 385, 387, 385, 387, 771, 386, 763, - 386, 385, 751, 385, 156, 385, 757, 386, 767, 390, - 78, 772, -490, -490, 297, 474, 390, 33, 424, 79, - 75, 4, 299, 390, 2, 390, 188, 5, 390, -15, - 78, 108, 386, 255, -490, -490, 297, 253, 545, 79, - 520, 4, 80, 392, 299, 81, 20, 5, 410, 411, - 412, 73, 390, 386, 417, 157, 254, 550, 2, 127, - 537, 387, 80, 387, 78, 81, 20, 744, 386, 745, - 387, 386, 658, 79, 540, 4, 82, 388, 659, 388, - 480, 5, -15, 482, 486, 386, 484, -490, -490, 297, - 459, 461, 463, 520, 386, 387, 80, 623, 648, 81, - 20, 488, 0, 386, 493, 0, 0, 0, 0, 0, - 126, 0, 386, 0, 0, 389, 387, 389, 386, 0, - -490, -490, 297, 0, 0, 0, 298, 386, 0, 386, - 521, 387, 0, 0, 387, 0, 0, 386, 0, 386, - 0, 0, 0, 0, 388, 386, 388, 386, 387, 386, - 0, 0, 0, 388, 0, 0, 0, 387, 0, 0, - 0, 0, 0, 0, 0, 0, 387, 0, 0, 0, - 0, 0, 0, 0, 0, 387, 0, 0, 388, 0, - 0, 387, 389, 0, 389, 0, 0, 0, 0, 78, - 387, 389, 387, 0, 0, 0, 0, 0, 194, 388, - 387, 0, 387, 390, 195, 390, 0, 0, 387, 0, - 387, 196, 387, 0, 388, 197, 389, 388, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 388, 200, 0, 0, 0, 0, 389, 0, 0, - 388, 202, 203, 204, 205, 0, 0, 206, 207, 388, - 0, 0, 389, 0, 0, 389, 0, 0, 388, 0, - 0, 0, 0, 0, 388, 0, 0, 0, 0, 389, - 390, 0, 390, 388, 0, 388, 0, 0, 389, 390, - 0, 0, 0, 388, 0, 388, 0, 389, 0, 0, - 0, 388, 0, 388, 0, 388, 389, 0, 0, 0, - 0, 0, 389, 0, 390, 0, 268, 268, 268, 268, - 0, 389, 0, 389, 268, 268, 0, 0, 0, 0, - 0, 389, 0, 389, 0, 390, 0, 0, 0, 389, - 0, 389, 0, 389, 0, 0, 269, 269, 269, 269, - 390, 0, 0, 390, 269, 269, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 390, 0, 0, - 0, 0, 0, 0, 0, 0, 390, 0, 0, 0, - 0, 0, 0, 0, 0, 390, 0, 0, 0, 0, - 0, 0, 0, 0, 390, 0, 0, 0, 0, 0, - 390, 0, 0, 0, 0, 0, 0, 0, 0, 390, - 0, 390, 0, 0, 0, 0, 0, 0, 0, 390, - 0, 390, 0, 0, 0, 0, 0, 390, 0, 390, - 0, 390, 0, 268, 268, 268, 268, 268, 268, 268, - 268, 268, 268, 268, 268, 0, 268, 268, 268, 268, - 268, 268, 268, 0, 331, 0, 0, 0, 0, 0, - 0, 0, 0, 269, 269, 269, 269, 269, 269, 269, - 269, 269, 269, 269, 269, 0, 269, 269, 269, 269, - 269, 269, 269, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 332, 192, 193, - 716, 333, 334, 78, 335, 0, 0, 336, 0, 0, - 0, 337, 194, 0, 0, 717, 0, 0, 338, 339, - 5, 340, 0, 341, 342, 196, 343, 0, 0, 344, + 176, 554, 29, 438, 450, 152, 459, 59, 84, 287, + 357, 67, 184, 442, 613, 325, 16, 117, 143, 38, + 93, 445, 174, 446, 20, 16, 16, 16, 342, 59, + 493, 462, 723, 48, 59, 84, 83, 76, 61, 719, + 84, 120, 61, 144, 62, 50, 16, 342, 694, 16, + 16, 249, 93, 124, 251, 174, 150, 153, 88, 558, + 61, 19, 260, 123, 327, 61, 363, 16, 83, 586, + 328, 165, 64, 262, 560, 84, 347, 146, 89, 84, + 334, 336, 338, 340, 474, 88, 482, 173, 349, 351, + 88, 479, 481, 59, 648, 186, 494, 463, 50, 67, + 719, 495, 673, 83, 165, 496, 84, 179, 84, 694, + 89, 316, 694, 246, -320, 20, 648, 39, 582, 40, + 173, 280, 137, 762, 61, 88, 84, 562, 343, 88, + 61, 49, 767, 50, 123, 77, 83, 25, 27, -155, + 145, 695, 741, 678, 345, 160, 20, 343, 353, 180, + 629, 125, 399, 632, 326, 396, 88, 559, 88, 607, + 41, 429, 457, 346, -94, -94, 422, -292, 587, 52, + 54, 281, 561, 57, 147, 694, 88, 741, 160, 483, + 694, 69, 694, 57, 694, 625, 698, 649, 331, 331, + 331, 331, 187, 618, 61, 674, 331, 331, 354, 84, + 701, 618, 695, 258, 245, 695, -320, 461, 600, 732, + 247, 603, 110, -97, 133, 618, 113, 575, -97, -97, + -97, -97, 42, 316, 610, 563, 129, 179, 688, 84, + 316, 650, 421, 280, 619, 742, 650, 555, 316, 647, + 316, 618, 708, 316, -30, 1, 651, 698, 622, 88, + 698, 651, 118, 280, -156, 110, 113, 434, 504, 506, + 508, 701, 668, 411, 701, 670, 355, 245, 695, 180, + 760, 438, 189, 695, 84, 695, 618, 695, 667, 88, + 652, 549, 389, 281, 659, 714, 450, 328, 2, 740, + 441, 756, 616, 119, 67, 482, 45, -104, 441, 3, + 441, -104, 179, 447, 682, 4, 407, 425, 282, 640, + 26, 5, 189, 698, 690, 576, 579, 704, 698, 432, + 698, 597, 698, 448, 88, 61, 157, 701, 528, 707, + 410, 620, 701, 416, 701, 128, 701, 731, 71, 316, + 751, 428, 101, 7, 180, 623, 438, -65, 20, 280, + 137, 367, 633, 692, 390, 709, 74, 148, 46, 669, + 450, 412, 671, -25, -25, 609, 331, 331, 331, 331, + 331, 331, 331, 331, 331, 331, 331, 331, 88, 331, + 331, 331, 331, 331, 331, 331, 630, 759, 577, 764, + -65, 417, 20, -66, 84, 20, 702, 317, 408, 551, + 42, 413, 724, 157, -25, 426, 433, -65, 427, -25, + -25, -25, 189, 750, 442, -25, 419, 445, 46, -25, + 282, 177, 434, 423, 743, 492, 454, 282, 318, 500, + 475, 134, -158, 167, 438, 282, -66, 282, 635, 633, + 747, -97, 710, -97, 88, 634, -97, -97, -97, -97, + -65, 450, 611, 753, 546, 601, 28, 31, 501, 189, + 450, 638, 641, 133, 2, 644, 167, 758, 486, 645, + 78, 645, 557, 331, 672, 135, 465, 407, 248, 331, + 692, 31, 565, 418, 567, 747, 53, 753, 316, 758, + -254, 316, 683, 100, 492, 57, 157, 498, 280, 676, + 106, 280, 80, 55, 58, 81, 20, 56, 420, 317, + 66, 744, -31, 1, 178, 424, 317, 590, 455, 592, + 98, 102, 476, 316, 317, 316, 317, -495, -495, 317, + 109, 636, 761, 598, 487, 131, 282, -28, 1, 112, + 318, 20, 727, 612, 492, 497, 601, 318, 281, 245, + 502, 281, 729, 639, 319, 318, 2, 318, 725, 20, + 318, 646, 149, 730, 57, 151, 316, 189, 154, 733, + 316, 20, 599, 4, 183, 599, 280, -29, 1, 5, + 188, 2, 324, 366, 203, 84, 601, 593, 20, 20, + 456, 316, 3, 460, 594, 20, 404, 405, 4, 316, + 406, 280, -34, 1, 5, 20, 20, 331, 331, 17, + 35, 7, 6, 179, 252, 20, 320, -139, 17, 17, + 17, 2, 464, 331, 20, 317, 281, 36, -33, 1, + 441, 316, 3, 37, 316, 88, 7, 360, 4, 17, + 253, 361, 17, 17, 5, 362, 2, 20, 138, 139, + 20, 281, 316, 20, 316, 180, 318, 316, 735, 20, + 17, 736, 280, 4, 280, 20, 319, 20, 20, 5, + 316, 90, 2, 319, 257, 20, 7, 134, 20, -32, + 1, 319, 680, 319, 316, 282, 319, 329, 282, 4, + 316, 441, -35, 1, 441, 5, 157, 316, 32, 316, + 344, 7, 316, 90, 316, 321, 316, 20, 99, 341, + 617, 458, 281, 103, 281, 712, 618, 441, 32, 527, + 684, 720, 32, 2, 765, 159, 618, 7, 320, 769, + 441, 771, 359, 772, 3, 320, 2, 703, 161, 32, + 4, 726, 364, 320, 441, 320, 5, 618, 320, 78, + -339, -339, 365, 4, 2, 385, 159, 441, 159, 5, + 78, 57, 441, 282, 441, 157, 441, 282, 78, 397, + 387, 161, 155, 386, 317, 493, 477, 317, 7, 478, + 2, 80, 319, 359, 81, 20, 78, 121, 282, 484, + 388, 7, 80, 485, 322, 81, 20, 752, 401, 493, + 80, 755, -339, 81, 20, 318, -339, 140, 318, 317, + 400, 317, 141, 142, 30, -154, 34, 321, 80, 728, + 435, 81, 20, 439, 321, 618, -341, -341, 282, 118, + 35, 282, 321, 359, 321, 469, 78, 321, 51, 578, + 318, 494, 318, 139, 320, 122, 495, 36, 583, 282, + 496, 282, 317, 37, 282, 568, 317, 250, 139, 569, + 20, -496, -496, 687, 602, 494, 604, 282, 80, 585, + 495, 81, 20, 2, 496, 368, 369, 317, -341, 78, + 626, 282, -341, 318, 20, 317, 443, 318, 79, 453, + 4, 370, 371, 372, 282, 550, 5, 373, 374, 282, + 595, 282, 621, 282, 383, 384, 322, 627, 318, 391, + 392, 80, 156, 322, 81, 20, 318, 317, 78, 631, + 317, 322, 637, 322, 323, 82, 322, 79, 647, 4, + 657, 319, 663, 321, 319, 5, -405, -405, 317, 2, + 317, -406, -406, 317, 664, 78, 141, 142, 318, 665, + 80, 318, 708, 81, 20, 601, 317, 375, 376, 377, + 721, 35, 587, 157, 158, 734, 319, 78, 319, 318, + 317, 318, 510, 512, 318, -205, 317, 80, 531, 533, + 81, 20, 737, 317, 37, 317, 738, 318, 317, 394, + 317, 35, 317, 320, 739, 740, 320, 78, 746, 80, + 748, 318, 81, 20, 466, 467, 468, 318, 756, 319, + 514, 516, 518, 319, 318, 757, 318, 763, 766, 318, + 768, 318, 322, 318, 378, 379, 380, 381, 320, 80, + 320, 2, 81, 20, 319, 770, 323, 78, 774, -494, + -494, 360, 319, 323, 775, 361, 79, 529, 4, 362, + 33, 323, 75, 323, 5, 108, 323, 395, 520, 522, + 524, 526, 190, 382, 156, 256, 553, 73, 254, 80, + 78, 320, 81, 20, 319, 320, 127, 319, 403, 79, + 449, 4, 321, 126, 715, 321, 716, 5, -494, -494, + 360, 452, 473, 642, 480, 319, 320, 319, 362, 535, + 319, 643, 80, -15, 320, 81, 20, 537, -494, -494, + 360, 541, 548, 319, 430, 157, 255, 321, 431, 321, + 539, 686, 0, -15, 543, 0, 0, 319, -494, -494, + 360, 0, 0, 319, 430, 0, 320, 0, 362, 320, + 319, 0, 319, 0, 0, 319, 0, 319, 0, 319, + 0, 0, 323, 0, 0, 0, 0, 320, 0, 320, + 321, -15, 320, 0, 321, 0, -494, -494, 360, 0, + 0, 322, 430, 0, 322, 320, 628, -494, -494, 360, + 0, 0, 0, 361, 0, 321, 0, 431, 0, 320, + 0, 0, 0, 321, 0, 320, 0, 0, 0, 0, + 0, 0, 320, 0, 320, 0, 322, 320, 322, 320, + 0, 320, 0, 0, 332, 332, 332, 332, 0, 0, + 0, 0, 332, 332, 0, 321, 0, 0, 321, 0, + 0, 0, 0, 0, 0, 333, 333, 333, 333, 0, + 0, 0, 0, 333, 333, 0, 321, 0, 321, 322, + 0, 321, 0, 322, 0, 0, 0, 0, 191, 0, + 192, 193, 0, 0, 321, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 322, 0, 0, 0, 321, 0, + 0, 0, 322, 0, 321, 0, 0, 0, 0, 0, + 0, 321, 0, 321, 0, 0, 321, 0, 321, 0, + 321, 323, 194, 195, 323, 0, 0, 78, 0, 0, + 0, 0, 0, 0, 322, 0, 196, 322, 0, 0, + 0, 0, 197, 0, 0, 0, 0, 0, 0, 198, + 0, 0, 0, 199, 0, 322, 323, 322, 323, 80, + 322, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 0, 203, 322, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 322, 0, 0, + 0, 0, 0, 322, 0, 0, 0, 0, 0, 323, + 322, 0, 322, 323, 0, 322, 0, 322, 677, 322, + 0, 0, 332, 332, 332, 332, 332, 332, 332, 332, + 332, 332, 332, 332, 323, 332, 332, 332, 332, 332, + 332, 332, 323, 333, 333, 333, 333, 333, 333, 333, + 333, 333, 333, 333, 333, 0, 333, 333, 333, 333, + 333, 333, 333, 0, 0, 0, 0, 78, 0, 0, + 0, 0, 0, 0, 323, 0, 196, 323, 0, 0, + 0, 0, 197, 0, 0, 0, 0, 0, 0, 198, + 0, 0, 0, 199, 0, 323, 0, 323, 0, 80, + 323, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 0, 0, 323, 263, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 323, 0, 332, + 0, 0, 0, 323, 0, 332, 0, 0, 0, 0, + 323, 0, 323, 0, 0, 323, 0, 323, 0, 323, + 333, 0, 0, 0, 0, 0, 333, 264, 194, 195, + 650, 265, 266, 78, 267, 0, 0, 268, 0, 0, + 0, 269, 196, 0, 0, 651, 0, 0, 270, 271, + 5, 272, 0, 273, 274, 198, 275, 0, 78, 276, + 0, 0, 0, 0, 0, 80, 0, 196, 81, 20, + 0, 0, 0, 197, 0, 0, 277, 0, 157, 717, + 198, 0, 278, 0, 199, 204, 205, 206, 207, 0, + 80, 208, 209, 81, 20, 0, 0, 200, 201, 0, + 0, 202, 0, 0, 0, 0, 0, 0, 0, 0, + 204, 205, 206, 207, 263, 0, 208, 209, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 332, 332, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 332, + 0, 0, 0, 0, 333, 333, 0, 264, 194, 195, + 650, 265, 266, 78, 267, 0, 0, 268, 0, 0, + 333, 269, 196, 0, 0, 651, 0, 0, 270, 271, + 5, 272, 263, 273, 274, 198, 275, 0, 0, 276, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 331, 0, 0, 0, 0, 345, 268, 157, 746, - 0, 0, 346, 268, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, - 0, 0, 0, 269, 332, 192, 193, 716, 333, 334, - 78, 335, 0, 0, 336, 0, 0, 0, 337, 194, - 0, 0, 717, 0, 0, 338, 339, 5, 340, 0, - 341, 342, 196, 343, 0, 574, 344, 190, 191, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 0, - 0, 0, 0, 345, 0, 157, 760, 0, 0, 346, - 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, - 193, 0, 0, 0, 78, 0, 0, 0, 0, 0, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 331, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 268, 268, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 0, 201, - 575, 0, 0, 268, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 0, 0, 0, 269, 269, 0, - 332, 192, 193, -261, 333, 334, 78, 335, 0, 0, - 336, 0, 0, 269, 337, 194, 0, 0, -261, 0, - 0, 338, 339, 5, 340, 331, 341, 342, 196, 343, - 0, 0, 344, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 0, 0, 0, 0, 345, - 0, 157, -261, 0, 0, 346, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 0, 0, 332, 192, - 193, 0, 333, 334, 78, 335, 0, 0, 336, 0, - 0, 0, 337, 194, 0, 0, 0, 0, 0, 338, - 339, 5, 340, 331, 341, 342, 196, 343, 0, 0, - 344, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 0, 0, 0, 0, 345, 0, 157, - 526, 0, 0, 346, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 0, 0, 332, 192, 193, 0, - 333, 334, 78, 335, 0, 0, 336, 0, 0, 0, - 337, 194, 0, 0, 0, 0, 0, 338, 339, 5, - 340, 331, 341, 342, 196, 343, 0, 0, 344, 0, - 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 0, 0, 0, 0, 345, 0, 157, 547, 0, - 0, 346, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 0, 0, 332, 192, 193, 0, 333, 334, - 78, 335, 0, 0, 336, 0, 0, 0, 337, 194, - 0, 0, 0, 0, 0, 338, 339, 5, 340, 331, - 341, 342, 196, 343, 0, 0, 344, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 0, - 0, 0, 0, 345, 0, 157, 624, 0, 0, 346, - 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 0, 0, 332, 192, 193, 0, 333, 334, 78, 335, - 0, 0, 336, 0, 0, 0, 337, 194, 0, 0, - 0, 0, 0, 338, 339, 5, 340, 331, 341, 342, - 196, 343, 0, 0, 344, 0, 0, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 0, 0, 0, - 0, 345, 0, 157, 627, 0, 0, 346, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 0, 0, - 332, 192, 193, 0, 333, 334, 78, 335, 0, 0, - 336, 0, 0, 0, 337, 194, 0, 0, 0, 0, - 0, 338, 339, 5, 340, 331, 341, 342, 196, 343, - 0, 0, 344, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 0, 0, 0, 0, 345, - 0, 157, 675, 0, 0, 346, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 0, 0, 332, 192, - 193, 0, 333, 334, 78, 335, 0, 0, 336, 0, - 0, 0, 337, 194, 0, 0, 0, 0, 0, 338, - 339, 5, 340, 331, 341, 342, 196, 343, 0, 0, - 344, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 0, 0, 0, 0, 345, 0, 157, - 0, 0, 0, 346, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 0, 0, 529, 192, 193, 0, - 333, 334, 78, 335, 0, 0, 336, 0, 0, 0, - 337, 194, 0, 0, 0, 0, 0, 338, 339, 331, - 340, 0, 341, 342, 196, 343, 0, 0, 344, 0, - 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 0, 0, 0, 0, 345, 0, 157, 0, 0, - 0, 346, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 529, 192, 193, 0, 682, 334, 78, 335, - 0, 0, 336, 0, 0, 0, 337, 194, 0, 0, - 0, 0, 0, 338, 339, 0, 340, 0, 341, 342, - 196, 343, 0, 189, 344, 190, 191, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 0, 0, 0, - 0, 345, 0, 157, 0, 0, 0, 346, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 192, 193, 0, - 0, 0, 78, 0, 489, 0, 190, 191, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 197, 0, + 0, 0, 0, 0, 0, 0, 277, 0, 157, 745, + 0, 0, 278, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209, 0, 0, 264, 194, 195, -264, 265, + 266, 78, 267, 0, 0, 268, 0, 0, 0, 269, + 196, 0, 0, -264, 0, 0, 270, 271, 5, 272, + 263, 273, 274, 198, 275, 0, 0, 276, 0, 0, + 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, + 0, 0, 0, 0, 277, 0, 157, -264, 0, 0, + 278, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 0, 0, 264, 194, 195, 0, 265, 266, 78, + 267, 0, 0, 268, 0, 0, 0, 269, 196, 0, + 0, 0, 0, 0, 270, 271, 5, 272, 263, 273, + 274, 198, 275, 0, 0, 276, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 0, 0, + 0, 0, 277, 0, 157, 436, 0, 0, 278, 0, + 0, 204, 205, 206, 207, 0, 0, 208, 209, 0, + 0, 264, 194, 195, 0, 265, 266, 78, 267, 0, + 0, 268, 0, 0, 0, 269, 196, 0, 0, 0, + 0, 0, 270, 271, 5, 272, 263, 273, 274, 198, + 275, 0, 0, 276, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 0, 0, 0, 0, + 277, 0, 157, 0, 0, 0, 278, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 0, 0, 440, + 194, 195, 0, 265, 266, 78, 267, 0, 0, 268, + 0, 0, 0, 269, 196, 0, 0, 0, 0, 0, + 270, 271, 263, 272, 0, 273, 274, 198, 275, 0, + 0, 276, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 0, 0, 0, 0, 277, 0, + 157, 0, 0, 0, 278, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 440, 194, 195, 0, 691, + 266, 78, 267, 0, 0, 268, 0, 0, 0, 269, + 196, 0, 0, 0, 0, 0, 270, 271, 0, 272, + 0, 273, 274, 198, 275, 0, 614, 276, 192, 193, + 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, + 0, 0, 0, 0, 277, 0, 157, 0, 0, 0, + 278, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 194, 195, 0, 0, 0, 78, 0, 0, 0, 0, + 0, 0, 0, 0, 196, 0, 0, 0, 0, 0, + 197, 414, 0, 192, 193, 0, 0, 198, 0, 0, + 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 200, 201, 0, 0, 202, 0, + 203, 615, 0, 0, 0, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 194, 195, 0, 0, 0, + 78, 0, 544, 0, 192, 193, 0, 0, 0, 196, + 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 80, 0, 0, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 0, 0, 194, 195, 0, 415, + 0, 78, 204, 205, 206, 207, 0, 0, 208, 209, + 196, 0, 0, 0, 0, 0, 197, 491, 0, 192, + 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, + 0, 0, 0, 80, 0, 0, 81, 20, 0, 545, + 200, 201, 0, 0, 202, 0, 0, 0, 0, 0, + 0, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 194, 195, 0, 0, 0, 78, 0, 580, 0, + 192, 193, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 197, 0, 0, 0, 0, 0, 0, 198, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, + 0, 81, 20, 0, 0, 200, 201, 0, 0, 202, + 0, 0, 194, 195, 148, 0, 0, 78, 204, 205, + 206, 207, 0, 0, 208, 209, 196, 0, 0, 0, + 0, 0, 197, 588, 0, 192, 193, 0, 0, 198, + 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 581, 0, 0, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 194, 195, 0, + 0, 0, 78, 0, 596, 0, 192, 193, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 197, 0, 0, + 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 198, 199, 0, 0, 200, 0, 201, 192, 193, - 0, 0, 0, 78, 202, 203, 204, 205, 0, 0, - 206, 207, 194, 0, 0, 0, 0, 0, 195, 504, - 0, 190, 191, 0, 0, 196, 0, 0, 0, 197, + 0, 200, 201, 0, 0, 202, 0, 0, 194, 195, + 0, 589, 0, 78, 204, 205, 206, 207, 0, 0, + 208, 209, 196, 0, 0, 0, 0, 0, 197, 605, + 0, 192, 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 490, 198, 199, 0, 0, 200, 0, 0, 0, - 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, - 556, 0, 190, 191, 0, 0, 0, 194, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 196, 0, 0, 0, 197, 0, 0, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 198, 199, 0, - 0, 200, 0, 0, 192, 193, 0, 505, 0, 78, - 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, - 0, 0, 0, 0, 195, 565, 0, 190, 191, 0, - 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 0, 200, 0, 0, 0, 0, 557, 0, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 192, - 193, 0, 0, 0, 78, 0, 436, 0, 190, 191, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 566, 0, - 192, 193, 0, 0, 0, 78, 202, 203, 204, 205, - 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, - 195, 436, 0, 190, 191, 0, 0, 196, 0, 0, - 0, 197, 0, 0, 0, 0, 0, 80, 0, 0, - 81, 20, 0, 0, 198, 199, 0, 0, 200, 0, - 0, 0, 0, 557, 0, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, - 78, 0, 611, 0, 190, 191, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 0, 196, 0, 0, 0, 197, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 198, - 199, 0, 0, 200, 0, 0, 192, 193, 148, 0, - 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, - 194, 0, 0, 0, 0, 0, 195, 617, 0, 190, - 191, 0, 0, 196, 0, 0, 0, 197, 0, 0, + 0, 0, 200, 201, 0, 0, 202, 0, 0, 0, + 0, 597, 0, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209, 194, 195, 0, 0, 0, 78, 0, + 491, 0, 192, 193, 0, 0, 0, 196, 0, 0, + 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, + 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, + 80, 0, 0, 81, 20, 0, 0, 200, 201, 0, + 0, 202, 606, 0, 194, 195, 0, 0, 0, 78, + 204, 205, 206, 207, 0, 0, 208, 209, 196, 0, + 0, 0, 0, 0, 197, 580, 0, 192, 193, 0, + 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 200, 201, + 0, 0, 202, 0, 0, 0, 0, 597, 0, 0, + 0, 204, 205, 206, 207, 0, 0, 208, 209, 194, + 195, 0, 0, 0, 78, 0, 705, 0, 192, 193, + 0, 0, 0, 196, 0, 0, 0, 0, 0, 197, + 0, 0, 0, 0, 0, 0, 198, 0, 0, 0, + 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, + 20, 0, 0, 200, 201, 0, 0, 202, 689, 0, + 194, 195, 0, 0, 0, 78, 204, 205, 206, 207, + 0, 0, 208, 209, 196, 0, 0, 0, 0, 0, + 197, 705, 0, 192, 193, 0, 0, 198, 0, 0, + 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 200, 201, 0, 0, 202, 706, + 0, 0, 0, 0, 0, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 194, 195, 0, 0, 0, + 78, 0, 588, 0, 192, 193, 0, 0, 0, 196, + 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 80, 0, 0, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 749, 0, 194, 195, 0, 0, + 0, 78, 204, 205, 206, 207, 0, 0, 208, 209, + 196, 0, 0, 0, 0, 0, 197, 330, 0, 192, + 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, - 198, 199, 0, 0, 200, 612, 0, 0, 0, 0, - 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 192, 193, 0, 0, 0, 78, 0, 611, 0, - 190, 191, 0, 0, 0, 194, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 196, 0, - 0, 0, 197, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 198, 199, 0, 0, 200, - 0, 0, 192, 193, 0, 618, 0, 78, 202, 203, - 204, 205, 0, 0, 206, 207, 194, 0, 0, 0, - 0, 0, 195, 698, 0, 190, 191, 0, 0, 196, - 0, 0, 0, 197, 0, 0, 0, 0, 0, 80, - 0, 0, 81, 20, 0, 0, 198, 199, 0, 0, - 200, 676, 0, 0, 0, 0, 0, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 192, 193, 0, - 0, 0, 78, 0, 698, 0, 190, 191, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 197, 0, + 200, 201, 0, 0, 202, 0, 0, 0, 0, 0, + 754, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 194, 195, 0, 0, 0, 78, 0, 335, 0, + 192, 193, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 197, 0, 0, 0, 0, 0, 0, 198, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, + 0, 81, 20, 0, 0, 200, 201, 0, 0, 202, + 0, 0, 194, 195, 0, 0, 0, 78, 204, 205, + 206, 207, 0, 0, 208, 209, 196, 0, 0, 0, + 0, 0, 197, 337, 0, 192, 193, 0, 0, 198, + 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 0, 0, 0, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 194, 195, 0, + 0, 0, 78, 0, 339, 0, 192, 193, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 197, 0, 0, + 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 198, 199, 0, 0, 200, 699, 0, 192, 193, - 0, 0, 0, 78, 202, 203, 204, 205, 0, 0, - 206, 207, 194, 0, 0, 0, 0, 0, 195, 617, - 0, 190, 191, 0, 0, 196, 0, 0, 0, 197, + 0, 200, 201, 0, 0, 202, 0, 0, 194, 195, + 0, 0, 0, 78, 204, 205, 206, 207, 0, 0, + 208, 209, 196, 0, 0, 0, 0, 0, 197, 348, + 0, 192, 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 0, 198, 199, 0, 0, 200, 731, 0, 0, - 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, - 266, 0, 190, 191, 0, 0, 0, 194, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 196, 0, 0, 0, 197, 0, 0, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 198, 199, 0, - 0, 200, 0, 0, 192, 193, 0, 736, 0, 78, - 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, - 0, 0, 0, 0, 195, 271, 0, 190, 191, 0, - 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 192, - 193, 0, 0, 0, 78, 0, 273, 0, 190, 191, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 0, 0, - 192, 193, 0, 0, 0, 78, 202, 203, 204, 205, - 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, - 195, 275, 0, 190, 191, 0, 0, 196, 0, 0, - 0, 197, 0, 0, 0, 0, 0, 80, 0, 0, - 81, 20, 0, 0, 198, 199, 0, 0, 200, 0, - 0, 0, 0, 0, 0, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, - 78, 0, 284, 0, 190, 191, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 0, 196, 0, 0, 0, 197, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 198, - 199, 0, 0, 200, 0, 0, 192, 193, 0, 0, - 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, - 194, 0, 0, 0, 0, 0, 195, 286, 0, 190, - 191, 0, 0, 196, 0, 0, 0, 197, 0, 0, + 0, 0, 200, 201, 0, 0, 202, 0, 0, 0, + 0, 0, 0, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209, 194, 195, 0, 0, 0, 78, 0, + 350, 0, 192, 193, 0, 0, 0, 196, 0, 0, + 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, + 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, + 80, 0, 0, 81, 20, 0, 0, 200, 201, 0, + 0, 202, 0, 0, 194, 195, 0, 0, 0, 78, + 204, 205, 206, 207, 0, 0, 208, 209, 196, 0, + 0, 0, 0, 0, 197, 352, 0, 192, 193, 0, + 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 200, 201, + 0, 0, 202, 0, 0, 0, 0, 0, 0, 0, + 0, 204, 205, 206, 207, 0, 0, 208, 209, 194, + 195, 0, 0, 0, 78, 0, 409, 0, 192, 193, + 0, 0, 0, 196, 0, 0, 0, 0, 0, 197, + 0, 0, 0, 0, 0, 0, 198, 0, 0, 0, + 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, + 20, 0, 0, 200, 201, 0, 0, 202, 0, 0, + 194, 195, 0, 0, 0, 78, 204, 205, 206, 207, + 0, 0, 208, 209, 196, 0, 0, 0, 0, 0, + 197, 491, 0, 192, 193, 0, 0, 198, 0, 0, + 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 200, 201, 0, 0, 202, 0, + 0, 0, 0, 0, 0, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 194, 195, 0, 0, 0, + 78, 0, 499, 0, 192, 193, 0, 0, 0, 196, + 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 80, 0, 0, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 0, 0, 194, 195, 0, 0, + 0, 78, 204, 205, 206, 207, 0, 0, 208, 209, + 196, 0, 0, 0, 0, 0, 197, 503, 0, 192, + 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, - 198, 199, 0, 0, 200, 0, 0, 0, 0, 0, - 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 192, 193, 0, 0, 0, 78, 0, 288, 0, - 190, 191, 0, 0, 0, 194, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 196, 0, - 0, 0, 197, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 198, 199, 0, 0, 200, - 0, 0, 192, 193, 0, 0, 0, 78, 202, 203, - 204, 205, 0, 0, 206, 207, 194, 0, 0, 0, - 0, 0, 195, 436, 0, 190, 191, 0, 0, 196, - 0, 0, 0, 197, 0, 0, 0, 0, 0, 80, - 0, 0, 81, 20, 0, 0, 198, 199, 0, 0, - 200, 0, 0, 0, 0, 0, 0, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 192, 193, 0, - 0, 0, 78, 0, 444, 0, 190, 191, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 197, 0, + 200, 201, 0, 0, 202, 0, 0, 0, 0, 0, + 0, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 194, 195, 0, 0, 0, 78, 0, 505, 0, + 192, 193, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 197, 0, 0, 0, 0, 0, 0, 198, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, + 0, 81, 20, 0, 0, 200, 201, 0, 0, 202, + 0, 0, 194, 195, 0, 0, 0, 78, 204, 205, + 206, 207, 0, 0, 208, 209, 196, 0, 0, 0, + 0, 0, 197, 507, 0, 192, 193, 0, 0, 198, + 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 0, 0, 0, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 194, 195, 0, + 0, 0, 78, 0, 509, 0, 192, 193, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 197, 0, 0, + 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 198, 199, 0, 0, 200, 0, 0, 192, 193, - 0, 0, 0, 78, 202, 203, 204, 205, 0, 0, - 206, 207, 194, 0, 0, 0, 0, 0, 195, 448, - 0, 190, 191, 0, 0, 196, 0, 0, 0, 197, + 0, 200, 201, 0, 0, 202, 0, 0, 194, 195, + 0, 0, 0, 78, 204, 205, 206, 207, 0, 0, + 208, 209, 196, 0, 0, 0, 0, 0, 197, 511, + 0, 192, 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 0, 198, 199, 0, 0, 200, 0, 0, 0, - 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, - 450, 0, 190, 191, 0, 0, 0, 194, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 196, 0, 0, 0, 197, 0, 0, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 198, 199, 0, - 0, 200, 0, 0, 192, 193, 0, 0, 0, 78, - 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, - 0, 0, 0, 0, 195, 452, 0, 190, 191, 0, - 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 192, - 193, 0, 0, 0, 78, 0, 454, 0, 190, 191, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 0, 0, - 192, 193, 0, 0, 0, 78, 202, 203, 204, 205, - 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, - 195, 456, 0, 190, 191, 0, 0, 196, 0, 0, - 0, 197, 0, 0, 0, 0, 0, 80, 0, 0, - 81, 20, 0, 0, 198, 199, 0, 0, 200, 0, - 0, 0, 0, 0, 0, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, - 78, 0, 458, 0, 190, 191, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 0, 196, 0, 0, 0, 197, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 198, - 199, 0, 0, 200, 0, 0, 192, 193, 0, 0, - 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, - 194, 0, 0, 0, 0, 0, 195, 460, 0, 190, - 191, 0, 0, 196, 0, 0, 0, 197, 0, 0, + 0, 0, 200, 201, 0, 0, 202, 0, 0, 0, + 0, 0, 0, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209, 194, 195, 0, 0, 0, 78, 0, + 513, 0, 192, 193, 0, 0, 0, 196, 0, 0, + 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, + 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, + 80, 0, 0, 81, 20, 0, 0, 200, 201, 0, + 0, 202, 0, 0, 194, 195, 0, 0, 0, 78, + 204, 205, 206, 207, 0, 0, 208, 209, 196, 0, + 0, 0, 0, 0, 197, 515, 0, 192, 193, 0, + 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 200, 201, + 0, 0, 202, 0, 0, 0, 0, 0, 0, 0, + 0, 204, 205, 206, 207, 0, 0, 208, 209, 194, + 195, 0, 0, 0, 78, 0, 517, 0, 192, 193, + 0, 0, 0, 196, 0, 0, 0, 0, 0, 197, + 0, 0, 0, 0, 0, 0, 198, 0, 0, 0, + 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, + 20, 0, 0, 200, 201, 0, 0, 202, 0, 0, + 194, 195, 0, 0, 0, 78, 204, 205, 206, 207, + 0, 0, 208, 209, 196, 0, 0, 0, 0, 0, + 197, 519, 0, 192, 193, 0, 0, 198, 0, 0, + 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 200, 201, 0, 0, 202, 0, + 0, 0, 0, 0, 0, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 194, 195, 0, 0, 0, + 78, 0, 521, 0, 192, 193, 0, 0, 0, 196, + 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 80, 0, 0, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 0, 0, 194, 195, 0, 0, + 0, 78, 204, 205, 206, 207, 0, 0, 208, 209, + 196, 0, 0, 0, 0, 0, 197, 523, 0, 192, + 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, - 198, 199, 0, 0, 200, 0, 0, 0, 0, 0, - 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 192, 193, 0, 0, 0, 78, 0, 462, 0, - 190, 191, 0, 0, 0, 194, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 196, 0, - 0, 0, 197, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 198, 199, 0, 0, 200, - 0, 0, 192, 193, 0, 0, 0, 78, 202, 203, - 204, 205, 0, 0, 206, 207, 194, 0, 0, 0, - 0, 0, 195, 464, 0, 190, 191, 0, 0, 196, - 0, 0, 0, 197, 0, 0, 0, 0, 0, 80, - 0, 0, 81, 20, 0, 0, 198, 199, 0, 0, - 200, 0, 0, 0, 0, 0, 0, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 192, 193, 0, - 0, 0, 78, 0, 466, 0, 190, 191, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 197, 0, + 200, 201, 0, 0, 202, 0, 0, 0, 0, 0, + 0, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 194, 195, 0, 0, 0, 78, 0, 525, 0, + 192, 193, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 197, 0, 0, 0, 0, 0, 0, 198, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, + 0, 81, 20, 0, 0, 200, 201, 0, 0, 202, + 0, 0, 194, 195, 0, 0, 0, 78, 204, 205, + 206, 207, 0, 0, 208, 209, 196, 0, 0, 0, + 0, 0, 197, 530, 0, 192, 193, 0, 0, 198, + 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 0, 0, 0, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 194, 195, 0, + 0, 0, 78, 0, 532, 0, 192, 193, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 197, 0, 0, + 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 198, 199, 0, 0, 200, 0, 0, 192, 193, - 0, 0, 0, 78, 202, 203, 204, 205, 0, 0, - 206, 207, 194, 0, 0, 0, 0, 0, 195, 468, - 0, 190, 191, 0, 0, 196, 0, 0, 0, 197, + 0, 200, 201, 0, 0, 202, 0, 0, 194, 195, + 0, 0, 0, 78, 204, 205, 206, 207, 0, 0, + 208, 209, 196, 0, 0, 0, 0, 0, 197, 534, + 0, 192, 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 0, 198, 199, 0, 0, 200, 0, 0, 0, - 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, - 470, 0, 190, 191, 0, 0, 0, 194, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 196, 0, 0, 0, 197, 0, 0, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 198, 199, 0, - 0, 200, 0, 0, 192, 193, 0, 0, 0, 78, - 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, - 0, 0, 0, 0, 195, 475, 0, 190, 191, 0, - 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 192, - 193, 0, 0, 0, 78, 0, 477, 0, 190, 191, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 0, 0, - 192, 193, 0, 0, 0, 78, 202, 203, 204, 205, - 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, - 195, 479, 0, 190, 191, 0, 0, 196, 0, 0, - 0, 197, 0, 0, 0, 0, 0, 80, 0, 0, - 81, 20, 0, 0, 198, 199, 0, 0, 200, 0, - 0, 0, 0, 0, 0, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, - 78, 0, 481, 0, 190, 191, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 0, 196, 0, 0, 0, 197, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 198, - 199, 0, 0, 200, 0, 0, 192, 193, 0, 0, - 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, - 194, 0, 0, 0, 0, 0, 195, 483, 0, 190, - 191, 0, 0, 196, 0, 0, 0, 197, 0, 0, + 0, 0, 200, 201, 0, 0, 202, 0, 0, 0, + 0, 0, 0, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209, 194, 195, 0, 0, 0, 78, 0, + 536, 0, 192, 193, 0, 0, 0, 196, 0, 0, + 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, + 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, + 80, 0, 0, 81, 20, 0, 0, 200, 201, 0, + 0, 202, 0, 0, 194, 195, 0, 0, 0, 78, + 204, 205, 206, 207, 0, 0, 208, 209, 196, 0, + 0, 0, 0, 0, 197, 538, 0, 192, 193, 0, + 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 200, 201, + 0, 0, 202, 0, 0, 0, 0, 0, 0, 0, + 0, 204, 205, 206, 207, 0, 0, 208, 209, 194, + 195, 0, 0, 0, 78, 0, 540, 0, 192, 193, + 0, 0, 0, 196, 0, 0, 0, 0, 0, 197, + 0, 0, 0, 0, 0, 0, 198, 0, 0, 0, + 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, + 20, 0, 0, 200, 201, 0, 0, 202, 0, 0, + 194, 195, 0, 0, 0, 78, 204, 205, 206, 207, + 0, 0, 208, 209, 196, 0, 0, 0, 0, 0, + 197, 542, 0, 192, 193, 0, 0, 198, 0, 0, + 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 200, 201, 0, 0, 202, 0, + 0, 0, 0, 0, 0, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 194, 195, 0, 0, 0, + 78, 0, 547, 0, 192, 193, 0, 0, 0, 196, + 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 80, 0, 0, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 0, 0, 194, 195, 0, 0, + 0, 78, 204, 205, 206, 207, 0, 0, 208, 209, + 196, 0, 0, 0, 0, 0, 197, 556, 0, 192, + 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, - 198, 199, 0, 0, 200, 0, 0, 0, 0, 0, - 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 192, 193, 0, 0, 0, 78, 0, 485, 0, - 190, 191, 0, 0, 0, 194, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 196, 0, - 0, 0, 197, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 198, 199, 0, 0, 200, - 0, 0, 192, 193, 0, 0, 0, 78, 202, 203, - 204, 205, 0, 0, 206, 207, 194, 0, 0, 0, - 0, 0, 195, 487, 0, 190, 191, 0, 0, 196, - 0, 0, 0, 197, 0, 0, 0, 0, 0, 80, - 0, 0, 81, 20, 0, 0, 198, 199, 0, 0, - 200, 0, 0, 0, 0, 0, 0, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 192, 193, 0, - 0, 0, 78, 0, 492, 0, 190, 191, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 197, 0, + 200, 201, 0, 0, 202, 0, 0, 0, 0, 0, + 0, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 194, 195, 0, 0, 0, 78, 0, 564, 0, + 192, 193, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 197, 0, 0, 0, 0, 0, 0, 198, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, + 0, 81, 20, 0, 0, 200, 201, 0, 0, 202, + 0, 0, 194, 195, 0, 0, 0, 78, 204, 205, + 206, 207, 0, 0, 208, 209, 196, 0, 0, 0, + 0, 0, 197, 566, 0, 192, 193, 0, 0, 198, + 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 0, 0, 0, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 194, 195, 0, + 0, 0, 78, 0, 591, 0, 192, 193, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 197, 0, 0, + 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 198, 199, 0, 0, 200, 0, 0, 192, 193, - 0, 0, 0, 78, 202, 203, 204, 205, 0, 0, - 206, 207, 194, 0, 0, 0, 0, 0, 195, 499, - 0, 190, 191, 0, 0, 196, 0, 0, 0, 197, + 0, 200, 201, 0, 0, 202, 0, 0, 194, 195, + 0, 0, 0, 78, 204, 205, 206, 207, 0, 0, + 208, 209, 196, 0, 0, 0, 0, 0, 197, 608, + 0, 192, 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 0, 198, 199, 0, 0, 200, 0, 0, 0, - 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, - 568, 0, 190, 191, 0, 0, 0, 194, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 196, 0, 0, 0, 197, 0, 0, 0, 0, 0, - 80, 0, 0, 81, 20, 0, 0, 198, 199, 0, - 0, 200, 0, 0, 192, 193, 0, 0, 0, 78, - 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, - 0, 0, 0, 0, 195, 588, 0, 190, 191, 0, - 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 192, - 193, 0, 0, 0, 78, 0, 596, 0, 190, 191, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 0, 0, - 192, 193, 0, 0, 0, 78, 202, 203, 204, 205, - 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, - 195, 598, 0, 190, 191, 0, 0, 196, 0, 0, - 0, 197, 0, 0, 0, 0, 0, 80, 0, 0, - 81, 20, 0, 0, 198, 199, 0, 0, 200, 0, - 0, 0, 0, 0, 0, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, - 78, 0, 620, 0, 190, 191, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 0, 196, 0, 0, 0, 197, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 198, - 199, 0, 0, 200, 0, 0, 192, 193, 0, 0, - 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, - 194, 0, 0, 0, 0, 0, 195, 637, 0, 190, - 191, 0, 0, 196, 0, 0, 0, 197, 0, 0, + 0, 0, 200, 201, 0, 0, 202, 0, 0, 0, + 0, 0, 0, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209, 194, 195, 0, 0, 0, 78, 0, + 675, 0, 192, 193, 0, 0, 0, 196, 0, 0, + 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, + 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, + 80, 0, 0, 81, 20, 0, 0, 200, 201, 0, + 0, 202, 0, 0, 194, 195, 0, 0, 0, 78, + 204, 205, 206, 207, 0, 0, 208, 209, 196, 0, + 0, 0, 0, 0, 197, 679, 0, 192, 193, 0, + 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 200, 201, + 0, 0, 202, 0, 0, 0, 0, 0, 0, 0, + 0, 204, 205, 206, 207, 0, 0, 208, 209, 194, + 195, 0, 0, 0, 78, 0, 685, 0, 192, 193, + 0, 0, 0, 196, 0, 0, 0, 0, 0, 197, + 0, 0, 0, 0, 0, 0, 198, 0, 0, 0, + 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, + 20, 0, 0, 200, 201, 0, 0, 202, 0, 0, + 194, 195, 0, 0, 0, 78, 204, 205, 206, 207, + 0, 0, 208, 209, 196, 0, 0, 0, 0, 0, + 197, 711, 0, 192, 193, 0, 0, 198, 0, 0, + 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 200, 201, 0, 0, 202, 0, + 0, 0, 0, 0, 0, 0, 0, 204, 205, 206, + 207, 0, 0, 208, 209, 194, 195, 0, 0, 0, + 78, 0, 574, 0, 0, 0, 0, 0, 0, 196, + 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 0, 198, 0, 0, 0, 199, 660, 0, 0, + 0, 0, 80, 0, 0, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 0, -287, -287, -287, 0, 0, + 0, -287, 204, 205, 206, 207, 0, 0, 208, 209, + -287, 0, 0, 0, 0, 0, -287, 0, 0, 722, + 0, 194, 195, -287, 0, 0, 78, -287, 0, 0, + 0, 0, 0, -287, 0, 196, -287, -287, 0, 0, + 0, 197, 0, 0, -287, 0, 192, 193, 198, 0, + -287, 0, 199, -287, -287, -287, -287, 0, 80, -287, + -287, 81, 20, 194, 195, 0, 0, 0, 78, 277, + -295, 0, 0, 0, 0, 0, 0, 196, 204, 205, + 206, 207, 0, 197, 208, 209, 658, 0, 194, 195, + 198, 0, 0, 78, 199, 0, 0, 0, 0, 0, + 80, 0, 196, 81, 20, 0, 0, 0, 197, 0, + 0, 277, -295, 192, 193, 198, 0, 0, 0, 199, + 204, 205, 206, 207, 0, 80, 208, 209, 81, 20, + 194, 195, 200, 201, 0, 78, 202, 0, 203, 356, + 0, 0, 0, 0, 196, 204, 205, 206, 207, 0, + 197, 208, 209, 0, 0, 194, 195, 198, 0, 0, + 78, 199, 0, 0, 192, 193, 0, 80, 0, 196, + 81, 20, 0, 0, 0, 197, 0, 0, 277, 0, + 0, 0, 198, 0, 0, 0, 199, 204, 205, 206, + 207, 0, 80, 208, 209, 81, 20, 0, 0, 200, + 201, 0, 0, 202, 488, 0, 194, 195, 0, 0, + 0, 78, 204, 205, 206, 207, 0, 0, 208, 209, + 196, 0, 0, 0, 0, 0, 197, 0, 0, 192, + 193, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, - 198, 199, 0, 0, 200, 0, 0, 0, 0, 0, - 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 192, 193, 0, 0, 0, 78, 0, 641, 0, - 190, 191, 0, 0, 0, 194, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 196, 0, - 0, 0, 197, 0, 0, 0, 0, 0, 80, 0, - 0, 81, 20, 0, 0, 198, 199, 0, 0, 200, - 0, 0, 192, 193, 0, 0, 0, 78, 202, 203, - 204, 205, 0, 0, 206, 207, 194, 0, 0, 0, - 0, 0, 195, 647, 0, 190, 191, 0, 0, 196, - 0, 0, 0, 197, 0, 0, 0, 0, 0, 80, - 0, 0, 81, 20, 0, 0, 198, 199, 0, 0, - 200, 0, 0, 0, 0, 0, 0, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 192, 193, 0, - 0, 0, 78, 0, 740, 0, 190, 191, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 197, 0, + 200, 201, 0, 0, 202, 624, 0, 0, 0, 0, + 0, 0, 0, 204, 205, 206, 207, 0, 0, 208, + 209, 194, 195, 0, 0, 0, 78, 0, 0, 0, + 192, 193, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 197, 0, 0, 0, 0, 0, 0, 198, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, + 0, 81, 20, 0, 0, 200, 201, 0, 0, 202, + 666, 0, 194, 195, 0, 0, 0, 78, 204, 205, + 206, 207, 0, 0, 208, 209, 196, 0, 0, 0, + 0, 0, 197, 0, 0, 192, 193, 0, 0, 198, + 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, + 0, 0, 81, 20, 0, 0, 200, 201, 0, 0, + 202, 681, 0, 0, 0, 0, 0, 0, 0, 204, + 205, 206, 207, 0, 0, 208, 209, 194, 195, 0, + 0, 0, 78, 0, 0, 0, 0, 0, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 197, 0, 0, + 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, 0, - 0, 198, 199, 0, 0, 200, 0, 0, 192, 193, - 0, 0, 0, 78, 202, 203, 204, 205, 0, 0, - 206, 207, 194, 0, 0, 0, 0, 0, 195, 0, - 605, 0, 0, 0, 0, 196, 0, 0, 0, 197, + 0, 200, 201, 0, 0, 202, 0, 2, 194, 195, + 0, 0, 0, 78, 204, 205, 206, 207, 0, 0, + 208, 209, 196, 0, 0, 0, 0, 0, 197, 0, + 0, 0, 0, 0, 0, 198, 0, 0, 0, 199, 0, 0, 0, 0, 0, 80, 0, 0, 81, 20, - 0, 0, 198, 199, 0, 668, 200, 0, 0, 0, - 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, -284, -284, -284, 0, 0, 0, -284, - 0, 0, 0, 0, 0, 0, 0, 0, -284, 0, - 0, 0, 0, 0, -284, 0, 0, 704, 0, 192, - 193, -284, 0, 0, 78, -284, 0, 0, 0, 0, - 0, -284, 0, 194, -284, -284, 0, 0, 0, 195, - 0, 0, -284, 0, 190, 191, 196, 0, -284, 0, - 197, -284, -284, -284, -284, 0, 80, -284, -284, 81, - 20, 192, 193, 0, 0, 0, 78, 345, -292, 0, - 0, 0, 0, 0, 0, 194, 202, 203, 204, 205, - 0, 195, 206, 207, 666, 0, 192, 193, 196, 0, - 0, 78, 197, 0, 0, 0, 0, 0, 80, 0, - 194, 81, 20, 0, 0, 0, 195, 0, 0, 345, - -292, 190, 191, 196, 0, 0, 0, 197, 202, 203, - 204, 205, 0, 80, 206, 207, 81, 20, 192, 193, - 198, 199, 0, 78, 200, 0, 201, 292, 0, 0, - 0, 293, 194, 202, 203, 204, 205, 0, 195, 206, - 207, 0, 0, 192, 193, 196, 0, 0, 78, 197, - 0, 0, 190, 191, 0, 80, 0, 194, 81, 20, - 0, 0, 0, 195, 0, 0, 345, 0, 0, 0, - 196, 0, 0, 0, 197, 202, 203, 204, 205, 0, - 80, 206, 207, 81, 20, 0, 0, 198, 199, 0, - 0, 200, 433, 0, 192, 193, 0, 0, 0, 78, - 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, - 0, 0, 0, 0, 195, 0, 0, 190, 191, 0, - 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, - 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, - 0, 0, 200, 584, 0, 0, 0, 0, 0, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 192, - 193, 0, 0, 0, 78, 0, 0, 0, 190, 191, - 0, 0, 0, 194, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, - 197, 0, 0, 0, 0, 0, 80, 0, 0, 81, - 20, 0, 0, 198, 199, 0, 0, 200, 628, 0, - 192, 193, 0, 0, 0, 78, 202, 203, 204, 205, - 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, - 195, 0, 0, 190, 191, 0, 0, 196, 0, 0, - 0, 197, 0, 0, 0, 0, 0, 80, 0, 0, - 81, 20, 0, 0, 198, 199, 0, 0, 200, 643, - 0, 0, 0, 0, 0, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, - 78, 0, 0, 0, 0, 0, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 0, 196, 0, 0, 0, 197, 0, 0, 0, - 0, 0, 80, 0, 0, 81, 20, 0, 0, 198, - 199, 0, 0, 200, 0, 2, 192, 193, 0, 0, - 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, - 194, 0, 0, 0, 0, 0, 195, 0, 0, 0, - 0, 0, 0, 196, 0, 0, 0, 197, 0, 0, - 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, - 0, 0, 0, 0, 345, 0, 0, 0, 0, 0, - 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207 + 0, 0, 0, 0, 0, 0, 277, 0, 0, 0, + 0, 0, 0, 0, 0, 204, 205, 206, 207, 0, + 0, 208, 209 }; static const short yycheck[] = { 3, - 132, 123, 6, 62, 264, 201, 0, 427, 129, 1, - 1, 1, 282, 1, 355, 9, 10, 11, 1, 289, - 290, 1, 0, 99, 100, 1, 1, 62, 1, 251, - 89, 9, 10, 11, 134, 94, 30, 374, 42, 33, - 34, 162, 46, 117, 86, 42, 1, 1, 169, 46, - 420, 53, 30, 100, 721, 33, 34, 51, 62, 94, - 64, 1, 362, 94, 101, 69, 97, 64, 62, 369, - 129, 371, 69, 51, 133, 62, 150, 447, 745, 153, - 63, 95, 4, 5, 62, 89, 1, 1, 140, 97, - 94, 67, 1, 101, 129, 97, 196, 171, 97, 1, - 94, 160, 89, 162, 1, 93, 98, 94, 99, 99, - 101, 101, 95, 101, 36, 37, 94, 1, 40, 178, - 95, 101, 1, 650, 128, 129, 99, 162, 50, 133, - 134, 128, 1, 52, 1, 129, 257, 134, 1, 133, - 95, 95, 129, 1, 414, 99, 133, 417, 200, 201, - 1, 129, 572, 1, 94, 525, 160, 79, 162, 686, - 100, 83, 689, 0, 1, 265, 1, 1, 162, 190, - 191, 192, 193, 160, 178, 162, 398, 198, 199, 253, - 1, 95, 1, 98, 162, 555, 190, 191, 192, 193, - 99, 178, 196, 252, 198, 199, 200, 99, 100, 196, - 122, 123, 99, 100, 1, 264, 1, 44, 1, 196, - 551, 581, 1, 200, 98, 94, 94, 139, 55, 251, - 341, 100, 95, 101, 61, 347, 99, 94, 755, 98, - 67, 94, 1, 100, 430, 1, 763, 100, 765, 1, - 767, 99, 1, 94, 1, 1, 298, 251, 252, 100, - 302, 99, 1, 1, 88, 177, 626, 1, 252, 1, - 264, 265, 99, 98, 251, 252, 97, 86, 265, 1, - 264, 100, 15, 1, 9, 327, 1, 264, 99, 616, - 99, 618, 334, 52, 625, 337, 307, 308, 309, 86, - 1, 661, 351, 345, 216, 1, 95, 1, 33, 88, - 95, 94, 99, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 355, 650, 1, 95, 549, 1, 251, - 362, 1, 319, 99, 671, 94, 98, 369, 708, 371, - 262, 98, 374, 99, 87, 94, 94, 351, 52, 650, - 650, 355, 0, 1, 93, 99, 98, 279, 362, 63, - 686, 413, 94, 689, 351, 369, 398, 371, 355, 650, - 374, 99, 424, 671, 99, 98, 1, 299, 430, 301, - 374, 1, 93, 251, 1, 686, 686, 374, 689, 689, - 63, 95, 98, 1, 398, 655, 44, 67, 1, 736, - 421, 94, 524, 703, 97, 686, 747, 55, 689, 129, - 86, 398, 712, 61, 336, 1, 1, 421, 1, 67, - 757, 343, 95, 427, 1, 347, 1, 75, 1, 755, - 730, 95, 52, 355, 566, 0, 1, 763, 736, 765, - 362, 767, 162, 63, 0, 1, 498, 369, 1, 371, - 1, 99, 584, 96, 755, 755, 508, 100, 510, 757, - 1, 86, 763, 763, 765, 765, 767, 767, 520, 1, - 1, 1, 96, 1, 755, 95, 398, 536, 1, 44, - 601, 1, 763, 86, 765, 93, 767, 355, 44, 541, - 55, 543, 45, 46, 362, 1, 61, 1, 72, 55, - 95, 369, 67, 371, 636, 61, 374, 93, 93, 93, - 93, 67, 86, 86, 646, 92, 93, 549, 93, 551, - 97, 98, 99, 100, 53, 1, 578, 0, 1, 251, - 398, 1, 536, 86, 99, 88, 129, 44, 91, 92, - 93, 100, 93, 99, 97, 549, 50, 551, 101, 536, - 571, 92, 673, 94, 61, 86, 97, 98, 99, 100, - 67, 93, 549, 93, 551, 93, 101, 571, 572, 162, - 93, 44, 65, 93, 50, 0, 1, 1, 82, 72, - 86, 85, 86, 587, 616, 1, 618, 95, 61, 97, - 1, 83, 1, 625, 67, 92, 655, 0, 1, 521, - 97, 98, 524, 724, 95, 96, 82, 177, 99, 85, - 86, 0, 1, 665, 107, 1, 86, 1, 650, 44, - 1, 625, 1, 5, 6, 7, 99, 549, 44, 551, - 122, 123, 414, 355, 50, 417, 61, 1, 625, 671, - 362, 44, 67, 101, 94, 1, 650, 369, 101, 371, - 100, 655, 374, 1, 686, 44, 97, 689, 61, 711, - 1, 655, 86, 715, 67, 717, 82, 1, 655, 85, - 86, 703, 61, 251, 99, 86, 398, 86, 67, 11, - 712, 549, 686, 551, 65, 689, 67, 12, 67, 721, - 1, 72, 262, 72, 5, 76, 99, 76, 730, 703, - 86, 623, 86, 625, 736, 86, 13, 86, 712, 65, - 99, 67, 1, 745, 97, 747, 72, 721, 101, 1, - 76, 1, 86, 755, 1, 757, 730, 14, 650, 1, - 86, 763, 99, 765, 721, 767, 251, 64, 86, 97, - 60, 745, 69, 747, 64, 86, 45, 46, 616, 96, - 618, 755, 86, 99, 100, 45, 46, 625, 745, 763, - 747, 765, 95, 767, 686, 93, 1, 689, 9, 97, - 11, 93, 44, 101, 44, 86, 93, 355, 50, 47, - 50, 703, 650, 99, 362, 47, 686, 99, 1, 689, - 712, 369, 33, 371, 62, 99, 374, 86, 97, 721, - 62, 128, 101, 671, 86, 129, 86, 97, 730, 86, - 82, 101, 82, 85, 86, 85, 86, 1, 686, 251, - 398, 689, 94, 745, 94, 747, 99, 549, 96, 551, - 99, 44, 93, 755, 96, 703, 160, 50, 162, 94, - 355, 763, 97, 765, 712, 767, 101, 362, 315, 316, - 317, 318, 94, 721, 369, 755, 371, 251, 100, 374, - 91, 92, 730, 763, 93, 765, 50, 767, 736, 82, - 44, 88, 85, 86, 94, 59, 50, 745, 94, 747, - 100, 65, 100, 398, 100, 94, 66, 755, 72, 757, - 10, 100, 76, 67, 616, 763, 618, 765, 82, 767, - 99, 85, 86, 625, 93, 89, 90, 94, 82, 93, - 30, 85, 86, 100, 34, 416, 1, 418, 102, 103, - 104, 105, 97, 355, 108, 109, 91, 92, 650, 86, - 362, 51, 45, 46, 91, 92, 93, 369, 94, 371, - 97, 1, 374, 93, 101, 251, 44, 3, 4, 671, - 16, 17, 50, 99, 18, 19, 20, 21, 94, 44, - 94, 355, 91, 92, 686, 50, 398, 689, 362, 97, - 98, 549, 1, 551, 59, 369, 61, 371, 94, 44, - 374, 703, 67, 100, 82, 50, 56, 85, 86, 56, - 712, 45, 46, 57, 59, 99, 61, 82, 94, 721, - 85, 86, 67, 94, 398, 91, 92, 93, 730, 45, - 46, 97, 310, 311, 736, 101, 1, 82, 320, 321, - 85, 86, 94, 745, 1, 747, 8, 9, 10, 56, - 95, 96, 94, 755, 549, 757, 551, 0, 616, 94, - 618, 763, 99, 765, 44, 767, 99, 625, 94, 355, - 50, 0, 91, 92, 93, 319, 362, 11, 97, 59, - 54, 61, 101, 369, 44, 371, 139, 67, 374, 86, - 50, 75, 650, 162, 91, 92, 93, 160, 393, 59, - 97, 61, 82, 252, 101, 85, 86, 67, 97, 98, - 99, 52, 398, 671, 282, 95, 96, 398, 44, 94, - 374, 616, 82, 618, 50, 85, 86, 719, 686, 719, - 625, 689, 602, 59, 374, 61, 96, 549, 602, 551, - 322, 67, 86, 323, 325, 703, 324, 91, 92, 93, - 312, 313, 314, 97, 712, 650, 82, 101, 587, 85, - 86, 326, -1, 721, 330, -1, -1, -1, -1, -1, - 96, -1, 730, -1, -1, 549, 671, 551, 736, -1, - 91, 92, 93, -1, -1, -1, 97, 745, -1, 747, - 101, 686, -1, -1, 689, -1, -1, 755, -1, 757, - -1, -1, -1, -1, 616, 763, 618, 765, 703, 767, - -1, -1, -1, 625, -1, -1, -1, 712, -1, -1, - -1, -1, -1, -1, -1, -1, 721, -1, -1, -1, - -1, -1, -1, -1, -1, 730, -1, -1, 650, -1, - -1, 736, 616, -1, 618, -1, -1, -1, -1, 50, - 745, 625, 747, -1, -1, -1, -1, -1, 59, 671, - 755, -1, 757, 549, 65, 551, -1, -1, 763, -1, - 765, 72, 767, -1, 686, 76, 650, 689, -1, -1, - -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, - -1, 703, 93, -1, -1, -1, -1, 671, -1, -1, - 712, 102, 103, 104, 105, -1, -1, 108, 109, 721, - -1, -1, 686, -1, -1, 689, -1, -1, 730, -1, - -1, -1, -1, -1, 736, -1, -1, -1, -1, 703, - 616, -1, 618, 745, -1, 747, -1, -1, 712, 625, - -1, -1, -1, 755, -1, 757, -1, 721, -1, -1, - -1, 763, -1, 765, -1, 767, 730, -1, -1, -1, - -1, -1, 736, -1, 650, -1, 190, 191, 192, 193, - -1, 745, -1, 747, 198, 199, -1, -1, -1, -1, - -1, 755, -1, 757, -1, 671, -1, -1, -1, 763, - -1, 765, -1, 767, -1, -1, 190, 191, 192, 193, - 686, -1, -1, 689, 198, 199, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 703, -1, -1, - -1, -1, -1, -1, -1, -1, 712, -1, -1, -1, - -1, -1, -1, -1, -1, 721, -1, -1, -1, -1, - -1, -1, -1, -1, 730, -1, -1, -1, -1, -1, - 736, -1, -1, -1, -1, -1, -1, -1, -1, 745, - -1, 747, -1, -1, -1, -1, -1, -1, -1, 755, - -1, 757, -1, -1, -1, -1, -1, 763, -1, 765, - -1, 767, -1, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, -1, 320, 321, 322, 323, - 324, 325, 326, -1, 1, -1, -1, -1, -1, -1, - -1, -1, -1, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, -1, 320, 321, 322, 323, - 324, 325, 326, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 44, 45, 46, + 132, 403, 6, 287, 307, 123, 328, 42, 62, 175, + 203, 46, 134, 294, 483, 179, 0, 83, 117, 1, + 62, 302, 129, 304, 86, 9, 10, 11, 1, 64, + 1, 1, 663, 1, 69, 89, 62, 1, 42, 655, + 94, 97, 46, 1, 95, 101, 30, 1, 634, 33, + 34, 150, 94, 1, 153, 162, 122, 123, 62, 1, + 64, 1, 169, 89, 94, 69, 1, 51, 94, 1, + 100, 129, 100, 172, 1, 129, 198, 1, 62, 133, + 192, 193, 194, 195, 346, 89, 1, 129, 200, 201, + 94, 353, 354, 128, 1, 1, 67, 67, 101, 134, + 716, 72, 1, 129, 162, 76, 160, 133, 162, 695, + 94, 175, 698, 1, 1, 86, 1, 99, 435, 101, + 162, 175, 1, 754, 128, 129, 180, 1, 101, 133, + 134, 99, 763, 101, 160, 99, 162, 4, 5, 93, + 98, 634, 1, 612, 198, 129, 86, 101, 202, 133, + 552, 99, 259, 555, 180, 254, 160, 99, 162, 476, + 1, 279, 326, 198, 99, 100, 273, 99, 100, 36, + 37, 175, 99, 40, 98, 761, 180, 1, 162, 94, + 766, 52, 768, 50, 770, 502, 634, 94, 192, 193, + 194, 195, 98, 100, 198, 94, 200, 201, 202, 253, + 634, 100, 695, 1, 140, 698, 93, 329, 470, 94, + 98, 473, 79, 92, 93, 100, 83, 1, 97, 98, + 99, 100, 63, 287, 1, 99, 95, 253, 630, 283, + 294, 47, 1, 287, 1, 94, 47, 403, 302, 1, + 304, 100, 1, 307, 0, 1, 62, 695, 1, 253, + 698, 62, 97, 307, 95, 122, 123, 283, 370, 371, + 372, 695, 1, 1, 698, 1, 202, 203, 761, 253, + 94, 555, 139, 766, 328, 768, 100, 770, 595, 283, + 96, 94, 15, 287, 587, 96, 589, 100, 44, 1, + 294, 1, 485, 97, 329, 1, 1, 95, 302, 55, + 304, 99, 328, 307, 621, 61, 1, 1, 175, 1, + 1, 67, 179, 761, 631, 99, 434, 639, 766, 1, + 768, 98, 770, 307, 328, 329, 95, 761, 382, 646, + 266, 98, 766, 269, 768, 100, 770, 99, 1, 403, + 99, 277, 1, 99, 328, 98, 630, 52, 86, 403, + 1, 218, 1, 634, 87, 1, 1, 98, 63, 98, + 663, 99, 98, 45, 46, 477, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 552, 99, 94, 99, + 95, 1, 86, 52, 448, 86, 1, 175, 93, 403, + 63, 268, 1, 95, 86, 99, 88, 52, 275, 91, + 92, 93, 279, 730, 695, 97, 1, 698, 63, 101, + 287, 1, 448, 1, 1, 361, 1, 294, 175, 365, + 1, 53, 95, 129, 718, 302, 95, 304, 1, 1, + 721, 92, 88, 94, 448, 94, 97, 98, 99, 100, + 95, 754, 94, 734, 390, 97, 1, 9, 1, 326, + 763, 1, 569, 93, 44, 572, 162, 748, 1, 1, + 50, 1, 408, 477, 606, 97, 343, 1, 1, 483, + 761, 33, 418, 93, 420, 766, 1, 768, 552, 770, + 95, 555, 624, 65, 430, 362, 95, 364, 552, 611, + 72, 555, 82, 1, 1, 85, 86, 5, 93, 287, + 1, 88, 0, 1, 94, 93, 294, 453, 93, 455, + 1, 1, 93, 587, 302, 589, 304, 91, 92, 307, + 1, 94, 94, 469, 67, 107, 403, 0, 1, 1, + 287, 86, 674, 94, 480, 72, 97, 294, 552, 485, + 93, 555, 684, 93, 175, 302, 44, 304, 665, 86, + 307, 93, 1, 93, 431, 1, 630, 434, 1, 93, + 634, 86, 470, 61, 1, 473, 630, 0, 1, 67, + 1, 44, 1, 1, 95, 639, 97, 94, 86, 86, + 1, 655, 55, 1, 101, 86, 95, 96, 61, 663, + 99, 655, 0, 1, 67, 86, 86, 611, 612, 0, + 44, 99, 75, 639, 96, 86, 175, 95, 9, 10, + 11, 44, 1, 627, 86, 403, 630, 61, 0, 1, + 634, 695, 55, 67, 698, 639, 99, 93, 61, 30, + 93, 97, 33, 34, 67, 101, 44, 86, 99, 100, + 86, 655, 716, 86, 718, 639, 403, 721, 695, 86, + 51, 698, 716, 61, 718, 86, 287, 86, 86, 67, + 734, 62, 44, 294, 99, 86, 99, 53, 86, 0, + 1, 302, 618, 304, 748, 552, 307, 100, 555, 61, + 754, 695, 0, 1, 698, 67, 95, 761, 10, 763, + 1, 99, 766, 94, 768, 175, 770, 86, 64, 101, + 94, 1, 716, 69, 718, 651, 100, 721, 30, 1, + 94, 657, 34, 44, 761, 129, 100, 99, 287, 766, + 734, 768, 101, 770, 55, 294, 44, 1, 129, 51, + 61, 94, 101, 302, 748, 304, 67, 100, 307, 50, + 45, 46, 97, 61, 44, 11, 160, 761, 162, 67, + 50, 628, 766, 630, 768, 95, 770, 634, 50, 99, + 13, 162, 128, 12, 552, 1, 94, 555, 99, 97, + 44, 82, 403, 101, 85, 86, 50, 1, 655, 96, + 14, 99, 82, 100, 175, 85, 86, 733, 95, 1, + 82, 737, 97, 85, 86, 552, 101, 92, 555, 587, + 99, 589, 97, 98, 9, 93, 11, 287, 82, 94, + 93, 85, 86, 99, 294, 100, 45, 46, 695, 97, + 44, 698, 302, 101, 304, 97, 50, 307, 33, 65, + 587, 67, 589, 100, 403, 59, 72, 61, 95, 716, + 76, 718, 630, 67, 721, 60, 634, 99, 100, 64, + 86, 91, 92, 65, 472, 67, 474, 734, 82, 66, + 72, 85, 86, 44, 76, 45, 46, 655, 97, 50, + 1, 748, 101, 630, 86, 663, 99, 634, 59, 99, + 61, 5, 6, 7, 761, 99, 67, 3, 4, 766, + 93, 768, 93, 770, 16, 17, 287, 88, 655, 91, + 92, 82, 44, 294, 85, 86, 663, 695, 50, 93, + 698, 302, 94, 304, 175, 96, 307, 59, 1, 61, + 93, 552, 99, 403, 555, 67, 45, 46, 716, 44, + 718, 45, 46, 721, 94, 50, 97, 98, 695, 94, + 82, 698, 1, 85, 86, 97, 734, 8, 9, 10, + 94, 44, 100, 95, 96, 56, 587, 50, 589, 716, + 748, 718, 373, 374, 721, 56, 754, 82, 383, 384, + 85, 86, 99, 761, 67, 763, 94, 734, 766, 94, + 768, 44, 770, 552, 94, 1, 555, 50, 94, 82, + 94, 748, 85, 86, 97, 98, 99, 754, 1, 630, + 375, 376, 377, 634, 761, 99, 763, 99, 94, 766, + 56, 768, 403, 770, 18, 19, 20, 21, 587, 82, + 589, 44, 85, 86, 655, 94, 287, 50, 0, 91, + 92, 93, 663, 294, 0, 97, 59, 382, 61, 101, + 11, 302, 54, 304, 67, 75, 307, 253, 378, 379, + 380, 381, 139, 57, 44, 162, 403, 52, 160, 82, + 50, 630, 85, 86, 695, 634, 94, 698, 261, 59, + 307, 61, 552, 96, 653, 555, 653, 67, 91, 92, + 93, 307, 346, 570, 97, 716, 655, 718, 101, 385, + 721, 570, 82, 86, 663, 85, 86, 386, 91, 92, + 93, 388, 393, 734, 97, 95, 96, 587, 101, 589, + 387, 627, -1, 86, 389, -1, -1, 748, 91, 92, + 93, -1, -1, 754, 97, -1, 695, -1, 101, 698, + 761, -1, 763, -1, -1, 766, -1, 768, -1, 770, + -1, -1, 403, -1, -1, -1, -1, 716, -1, 718, + 630, 86, 721, -1, 634, -1, 91, 92, 93, -1, + -1, 552, 97, -1, 555, 734, 101, 91, 92, 93, + -1, -1, -1, 97, -1, 655, -1, 101, -1, 748, + -1, -1, -1, 663, -1, 754, -1, -1, -1, -1, + -1, -1, 761, -1, 763, -1, 587, 766, 589, 768, + -1, 770, -1, -1, 192, 193, 194, 195, -1, -1, + -1, -1, 200, 201, -1, 695, -1, -1, 698, -1, + -1, -1, -1, -1, -1, 192, 193, 194, 195, -1, + -1, -1, -1, 200, 201, -1, 716, -1, 718, 630, + -1, 721, -1, 634, -1, -1, -1, -1, 1, -1, + 3, 4, -1, -1, 734, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 655, -1, -1, -1, 748, -1, + -1, -1, 663, -1, 754, -1, -1, -1, -1, -1, + -1, 761, -1, 763, -1, -1, 766, -1, 768, -1, + 770, 552, 45, 46, 555, -1, -1, 50, -1, -1, + -1, -1, -1, -1, 695, -1, 59, 698, -1, -1, + -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, + -1, -1, -1, 76, -1, 716, 587, 718, 589, 82, + 721, -1, 85, 86, -1, -1, 89, 90, -1, -1, + 93, -1, 95, 734, -1, -1, -1, -1, -1, 102, + 103, 104, 105, -1, -1, 108, 109, 748, -1, -1, + -1, -1, -1, 754, -1, -1, -1, -1, -1, 630, + 761, -1, 763, 634, -1, 766, -1, 768, 1, 770, + -1, -1, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 655, 383, 384, 385, 386, 387, + 388, 389, 663, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, + 387, 388, 389, -1, -1, -1, -1, 50, -1, -1, + -1, -1, -1, -1, 695, -1, 59, 698, -1, -1, + -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, + -1, -1, -1, 76, -1, 716, -1, 718, -1, 82, + 721, -1, 85, 86, -1, -1, 89, 90, -1, -1, + 93, -1, -1, 734, 1, -1, -1, -1, -1, 102, + 103, 104, 105, -1, -1, 108, 109, 748, -1, 477, + -1, -1, -1, 754, -1, 483, -1, -1, -1, -1, + 761, -1, 763, -1, -1, 766, -1, 768, -1, 770, + 477, -1, -1, -1, -1, -1, 483, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, 54, -1, -1, -1, 58, 59, -1, -1, 62, -1, -1, 65, 66, - 67, 68, -1, 70, 71, 72, 73, -1, -1, 76, + 67, 68, -1, 70, 71, 72, 73, -1, 50, 76, + -1, -1, -1, -1, -1, 82, -1, 59, 85, 86, + -1, -1, -1, 65, -1, -1, 93, -1, 95, 96, + 72, -1, 99, -1, 76, 102, 103, 104, 105, -1, + 82, 108, 109, 85, 86, -1, -1, 89, 90, -1, + -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, + 102, 103, 104, 105, 1, -1, 108, 109, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 611, 612, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 627, + -1, -1, -1, -1, 611, 612, -1, 44, 45, 46, + 47, 48, 49, 50, 51, -1, -1, 54, -1, -1, + 627, 58, 59, -1, -1, 62, -1, -1, 65, 66, + 67, 68, 1, 70, 71, 72, 73, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, - -1, 1, -1, -1, -1, -1, 93, 421, 95, 96, - -1, -1, 99, 427, -1, 102, 103, 104, 105, -1, - -1, 108, 109, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 421, -1, -1, - -1, -1, -1, 427, 44, 45, 46, 47, 48, 49, - 50, 51, -1, -1, 54, -1, -1, -1, 58, 59, - -1, -1, 62, -1, -1, 65, 66, 67, 68, -1, - 70, 71, 72, 73, -1, 1, 76, 3, 4, -1, - -1, -1, 82, -1, -1, 85, 86, -1, -1, -1, - -1, -1, -1, 93, -1, 95, 96, -1, -1, 99, - -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 45, - 46, -1, -1, -1, 50, -1, -1, -1, -1, -1, - -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, - -1, -1, -1, -1, -1, -1, 72, 1, -1, -1, - 76, -1, -1, -1, -1, -1, 82, 571, 572, 85, - 86, -1, -1, 89, 90, -1, -1, 93, -1, 95, - 96, -1, -1, 587, -1, -1, 102, 103, 104, 105, - -1, -1, 108, 109, -1, -1, -1, 571, 572, -1, - 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, - 54, -1, -1, 587, 58, 59, -1, -1, 62, -1, - -1, 65, 66, 67, 68, 1, 70, 71, 72, 73, - -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, - -1, 85, 86, -1, -1, -1, -1, -1, -1, 93, - -1, 95, 96, -1, -1, 99, -1, -1, 102, 103, - 104, 105, -1, -1, 108, 109, -1, -1, 44, 45, - 46, -1, 48, 49, 50, 51, -1, -1, 54, -1, - -1, -1, 58, 59, -1, -1, -1, -1, -1, 65, - 66, 67, 68, 1, 70, 71, 72, 73, -1, -1, - 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, - 86, -1, -1, -1, -1, -1, -1, 93, -1, 95, - 96, -1, -1, 99, -1, -1, 102, 103, 104, 105, - -1, -1, 108, 109, -1, -1, 44, 45, 46, -1, - 48, 49, 50, 51, -1, -1, 54, -1, -1, -1, - 58, 59, -1, -1, -1, -1, -1, 65, 66, 67, - 68, 1, 70, 71, 72, 73, -1, -1, 76, -1, - -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, - -1, -1, -1, -1, -1, 93, -1, 95, 96, -1, - -1, 99, -1, -1, 102, 103, 104, 105, -1, -1, - 108, 109, -1, -1, 44, 45, 46, -1, 48, 49, - 50, 51, -1, -1, 54, -1, -1, -1, 58, 59, - -1, -1, -1, -1, -1, 65, 66, 67, 68, 1, - 70, 71, 72, 73, -1, -1, 76, -1, -1, -1, - -1, -1, 82, -1, -1, 85, 86, -1, -1, -1, - -1, -1, -1, 93, -1, 95, 96, -1, -1, 99, - -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, - -1, -1, 44, 45, 46, -1, 48, 49, 50, 51, - -1, -1, 54, -1, -1, -1, 58, 59, -1, -1, - -1, -1, -1, 65, 66, 67, 68, 1, 70, 71, - 72, 73, -1, -1, 76, -1, -1, -1, -1, -1, - 82, -1, -1, 85, 86, -1, -1, -1, -1, -1, - -1, 93, -1, 95, 96, -1, -1, 99, -1, -1, - 102, 103, 104, 105, -1, -1, 108, 109, -1, -1, - 44, 45, 46, -1, 48, 49, 50, 51, -1, -1, - 54, -1, -1, -1, 58, 59, -1, -1, -1, -1, - -1, 65, 66, 67, 68, 1, 70, 71, 72, 73, + -1, -1, -1, -1, -1, -1, 93, -1, 95, 96, + -1, -1, 99, -1, -1, 102, 103, 104, 105, -1, + -1, 108, 109, -1, -1, 44, 45, 46, 47, 48, + 49, 50, 51, -1, -1, 54, -1, -1, -1, 58, + 59, -1, -1, 62, -1, -1, 65, 66, 67, 68, + 1, 70, 71, 72, 73, -1, -1, 76, -1, -1, + -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, + -1, -1, -1, -1, 93, -1, 95, 96, -1, -1, + 99, -1, -1, 102, 103, 104, 105, -1, -1, 108, + 109, -1, -1, 44, 45, 46, -1, 48, 49, 50, + 51, -1, -1, 54, -1, -1, -1, 58, 59, -1, + -1, -1, -1, -1, 65, 66, 67, 68, 1, 70, + 71, 72, 73, -1, -1, 76, -1, -1, -1, -1, + -1, 82, -1, -1, 85, 86, -1, -1, -1, -1, + -1, -1, 93, -1, 95, 96, -1, -1, 99, -1, + -1, 102, 103, 104, 105, -1, -1, 108, 109, -1, + -1, 44, 45, 46, -1, 48, 49, 50, 51, -1, + -1, 54, -1, -1, -1, 58, 59, -1, -1, -1, + -1, -1, 65, 66, 67, 68, 1, 70, 71, 72, + 73, -1, -1, 76, -1, -1, -1, -1, -1, 82, + -1, -1, 85, 86, -1, -1, -1, -1, -1, -1, + 93, -1, 95, -1, -1, -1, 99, -1, -1, 102, + 103, 104, 105, -1, -1, 108, 109, -1, -1, 44, + 45, 46, -1, 48, 49, 50, 51, -1, -1, 54, + -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, + 65, 66, 1, 68, -1, 70, 71, 72, 73, -1, + -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, + 85, 86, -1, -1, -1, -1, -1, -1, 93, -1, + 95, -1, -1, -1, 99, -1, -1, 102, 103, 104, + 105, -1, -1, 108, 109, 44, 45, 46, -1, 48, + 49, 50, 51, -1, -1, 54, -1, -1, -1, 58, + 59, -1, -1, -1, -1, -1, 65, 66, -1, 68, + -1, 70, 71, 72, 73, -1, 1, 76, 3, 4, + -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, + -1, -1, -1, -1, 93, -1, 95, -1, -1, -1, + 99, -1, -1, 102, 103, 104, 105, -1, -1, 108, + 109, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 45, 46, -1, -1, -1, 50, -1, -1, -1, -1, + -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, + 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, + -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, + 85, 86, -1, -1, 89, 90, -1, -1, 93, -1, + 95, 96, -1, -1, -1, -1, -1, 102, 103, 104, + 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, + 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, + -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, + -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, + -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, + 90, -1, -1, 93, -1, -1, 45, 46, -1, 99, + -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, + 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, + 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, + -1, -1, -1, 82, -1, -1, 85, 86, -1, 88, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, + 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, + 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, + -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, - -1, 85, 86, -1, -1, -1, -1, -1, -1, 93, - -1, 95, 96, -1, -1, 99, -1, -1, 102, 103, - 104, 105, -1, -1, 108, 109, -1, -1, 44, 45, - 46, -1, 48, 49, 50, 51, -1, -1, 54, -1, - -1, -1, 58, 59, -1, -1, -1, -1, -1, 65, - 66, 67, 68, 1, 70, 71, 72, 73, -1, -1, - 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, - 86, -1, -1, -1, -1, -1, -1, 93, -1, 95, - -1, -1, -1, 99, -1, -1, 102, 103, 104, 105, - -1, -1, 108, 109, -1, -1, 44, 45, 46, -1, - 48, 49, 50, 51, -1, -1, 54, -1, -1, -1, - 58, 59, -1, -1, -1, -1, -1, 65, 66, 1, - 68, -1, 70, 71, 72, 73, -1, -1, 76, -1, - -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, - -1, -1, -1, -1, -1, 93, -1, 95, -1, -1, - -1, 99, -1, -1, 102, 103, 104, 105, -1, -1, - 108, 109, 44, 45, 46, -1, 48, 49, 50, 51, - -1, -1, 54, -1, -1, -1, 58, 59, -1, -1, - -1, -1, -1, 65, 66, -1, 68, -1, 70, 71, - 72, 73, -1, 1, 76, 3, 4, -1, -1, -1, - 82, -1, -1, 85, 86, -1, -1, -1, -1, -1, - -1, 93, -1, 95, -1, -1, -1, 99, -1, -1, - 102, 103, 104, 105, -1, -1, 108, 109, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 45, 46, -1, + -1, 85, 86, -1, -1, 89, 90, -1, -1, 93, + -1, -1, 45, 46, 98, -1, -1, 50, 102, 103, + 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, + -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, + -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, + -1, -1, 85, 86, -1, -1, 89, 90, -1, -1, + 93, 94, -1, -1, -1, -1, -1, -1, -1, 102, + 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, - -1, 89, 90, -1, -1, 93, -1, 95, 45, 46, - -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, + -1, 89, 90, -1, -1, 93, -1, -1, 45, 46, + -1, 99, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, - -1, 88, 89, 90, -1, -1, 93, -1, -1, -1, - -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, + -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, + -1, 98, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, -1, - -1, 93, -1, -1, 45, 46, -1, 99, -1, 50, + -1, 93, 94, -1, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, @@ -1760,49 +1931,49 @@ static const short yycheck[] = { 3, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, - 85, 86, -1, -1, 89, 90, -1, -1, 93, -1, - -1, -1, -1, 98, -1, -1, -1, 102, 103, 104, + 85, 86, -1, -1, 89, 90, -1, -1, 93, 94, + -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, - 90, -1, -1, 93, -1, -1, 45, 46, 98, -1, + 90, -1, -1, 93, 94, -1, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, - 89, 90, -1, -1, 93, 94, -1, -1, -1, -1, - -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, -1, -1, 93, - -1, -1, 45, 46, -1, 99, -1, 50, 102, 103, + -1, -1, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, -1, -1, - 93, 94, -1, -1, -1, -1, -1, -1, -1, 102, + 93, -1, -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, - -1, 89, 90, -1, -1, 93, 94, -1, 45, 46, + -1, 89, 90, -1, -1, 93, -1, -1, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, - -1, -1, 89, 90, -1, -1, 93, 94, -1, -1, + -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, -1, - -1, 93, -1, -1, 45, 46, -1, 99, -1, 50, + -1, 93, -1, -1, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, @@ -1995,97 +2166,67 @@ static const short yycheck[] = { 3, 85, 86, -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, - 50, -1, 1, -1, 3, 4, -1, -1, -1, 59, + 50, -1, 1, -1, -1, -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, - -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, + -1, -1, 72, -1, -1, -1, 76, 1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, - 90, -1, -1, 93, -1, -1, 45, 46, -1, -1, + 90, -1, -1, 93, -1, 44, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, - 59, -1, -1, -1, -1, -1, 65, 1, -1, 3, + 59, -1, -1, -1, -1, -1, 65, -1, -1, 1, + -1, 45, 46, 72, -1, -1, 50, 76, -1, -1, + -1, -1, -1, 82, -1, 59, 85, 86, -1, -1, + -1, 65, -1, -1, 93, -1, 3, 4, 72, -1, + 99, -1, 76, 102, 103, 104, 105, -1, 82, 108, + 109, 85, 86, 45, 46, -1, -1, -1, 50, 93, + 94, -1, -1, -1, -1, -1, -1, 59, 102, 103, + 104, 105, -1, 65, 108, 109, 1, -1, 45, 46, + 72, -1, -1, 50, 76, -1, -1, -1, -1, -1, + 82, -1, 59, 85, 86, -1, -1, -1, 65, -1, + -1, 93, 94, 3, 4, 72, -1, -1, -1, 76, + 102, 103, 104, 105, -1, 82, 108, 109, 85, 86, + 45, 46, 89, 90, -1, 50, 93, -1, 95, 96, + -1, -1, -1, -1, 59, 102, 103, 104, 105, -1, + 65, 108, 109, -1, -1, 45, 46, 72, -1, -1, + 50, 76, -1, -1, 3, 4, -1, 82, -1, 59, + 85, 86, -1, -1, -1, 65, -1, -1, 93, -1, + -1, -1, 72, -1, -1, -1, 76, 102, 103, 104, + 105, -1, 82, 108, 109, 85, 86, -1, -1, 89, + 90, -1, -1, 93, 94, -1, 45, 46, -1, -1, + -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, + 59, -1, -1, -1, -1, -1, 65, -1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, - 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, 94, -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, - 109, 45, 46, -1, -1, -1, 50, -1, 1, -1, + 109, 45, 46, -1, -1, -1, 50, -1, -1, -1, 3, 4, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, -1, -1, 93, - -1, -1, 45, 46, -1, -1, -1, 50, 102, 103, + 94, -1, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, - -1, -1, 65, 1, -1, 3, 4, -1, -1, 72, + -1, -1, 65, -1, -1, 3, 4, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, -1, -1, - 93, -1, -1, -1, -1, -1, -1, -1, -1, 102, + 93, 94, -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, 46, -1, - -1, -1, 50, -1, 1, -1, 3, 4, -1, -1, + -1, -1, 50, -1, -1, -1, -1, -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, -1, - -1, 89, 90, -1, -1, 93, -1, -1, 45, 46, + -1, 89, 90, -1, -1, 93, -1, 44, 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, 65, -1, - 1, -1, -1, -1, -1, 72, -1, -1, -1, 76, + -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, 86, - -1, -1, 89, 90, -1, 1, 93, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, 105, -1, - -1, 108, 109, 44, 45, 46, -1, -1, -1, 50, - -1, -1, -1, -1, -1, -1, -1, -1, 59, -1, - -1, -1, -1, -1, 65, -1, -1, 1, -1, 45, - 46, 72, -1, -1, 50, 76, -1, -1, -1, -1, - -1, 82, -1, 59, 85, 86, -1, -1, -1, 65, - -1, -1, 93, -1, 3, 4, 72, -1, 99, -1, - 76, 102, 103, 104, 105, -1, 82, 108, 109, 85, - 86, 45, 46, -1, -1, -1, 50, 93, 94, -1, - -1, -1, -1, -1, -1, 59, 102, 103, 104, 105, - -1, 65, 108, 109, 1, -1, 45, 46, 72, -1, - -1, 50, 76, -1, -1, -1, -1, -1, 82, -1, - 59, 85, 86, -1, -1, -1, 65, -1, -1, 93, - 94, 3, 4, 72, -1, -1, -1, 76, 102, 103, - 104, 105, -1, 82, 108, 109, 85, 86, 45, 46, - 89, 90, -1, 50, 93, -1, 95, 96, -1, -1, - -1, 100, 59, 102, 103, 104, 105, -1, 65, 108, - 109, -1, -1, 45, 46, 72, -1, -1, 50, 76, - -1, -1, 3, 4, -1, 82, -1, 59, 85, 86, - -1, -1, -1, 65, -1, -1, 93, -1, -1, -1, - 72, -1, -1, -1, 76, 102, 103, 104, 105, -1, - 82, 108, 109, 85, 86, -1, -1, 89, 90, -1, - -1, 93, 94, -1, 45, 46, -1, -1, -1, 50, - 102, 103, 104, 105, -1, -1, 108, 109, 59, -1, - -1, -1, -1, -1, 65, -1, -1, 3, 4, -1, - -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, - -1, 82, -1, -1, 85, 86, -1, -1, 89, 90, - -1, -1, 93, 94, -1, -1, -1, -1, -1, -1, - -1, 102, 103, 104, 105, -1, -1, 108, 109, 45, - 46, -1, -1, -1, 50, -1, -1, -1, 3, 4, - -1, -1, -1, 59, -1, -1, -1, -1, -1, 65, - -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, - 76, -1, -1, -1, -1, -1, 82, -1, -1, 85, - 86, -1, -1, 89, 90, -1, -1, 93, 94, -1, - 45, 46, -1, -1, -1, 50, 102, 103, 104, 105, - -1, -1, 108, 109, 59, -1, -1, -1, -1, -1, - 65, -1, -1, 3, 4, -1, -1, 72, -1, -1, - -1, 76, -1, -1, -1, -1, -1, 82, -1, -1, - 85, 86, -1, -1, 89, 90, -1, -1, 93, 94, - -1, -1, -1, -1, -1, -1, -1, 102, 103, 104, - 105, -1, -1, 108, 109, 45, 46, -1, -1, -1, - 50, -1, -1, -1, -1, -1, -1, -1, -1, 59, - -1, -1, -1, -1, -1, 65, -1, -1, -1, -1, - -1, -1, 72, -1, -1, -1, 76, -1, -1, -1, - -1, -1, 82, -1, -1, 85, 86, -1, -1, 89, - 90, -1, -1, 93, -1, 44, 45, 46, -1, -1, - -1, 50, 102, 103, 104, 105, -1, -1, 108, 109, - 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, - -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, - -1, -1, -1, 82, -1, -1, 85, 86, -1, -1, - -1, -1, -1, -1, 93, -1, -1, -1, -1, -1, - -1, -1, -1, 102, 103, 104, 105, -1, -1, 108, - 109 + -1, 108, 109 }; #define YYPURE 1 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/usr/cygnus/gnupro-98r1/share/bison.simple" +#line 3 "/usr/lib/bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. @@ -2278,7 +2419,7 @@ __yy_memcpy (char *to, char *from, int count) #endif #endif -#line 196 "/usr/cygnus/gnupro-98r1/share/bison.simple" +#line 196 "/usr/lib/bison.simple" /* The user can define YYPARSE_PARAM as the name of an argument to be passed into yyparse. The argument should have type void *. @@ -2583,66 +2724,66 @@ yyreduce: switch (yyn) { case 1: -#line 253 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 456 "./parse.y" {; break;} case 18: -#line 297 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 500 "./parse.y" { yyval.node = build_java_array_type (yyvsp[-2].node, -1); CLASS_LOADED_P (yyval.node) = 1; ; break;} case 19: -#line 302 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 505 "./parse.y" { yyval.node = build_unresolved_array_type (yyvsp[-2].node); ; break;} case 20: -#line 304 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 507 "./parse.y" { yyval.node = build_unresolved_array_type (yyvsp[-2].node); ; break;} case 21: -#line 306 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 509 "./parse.y" {RULE ("']' expected"); RECOVER;; break;} case 22: -#line 308 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 511 "./parse.y" {RULE ("']' expected"); RECOVER;; break;} case 26: -#line 323 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 526 "./parse.y" { yyval.node = make_qualified_name (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); ; break;} case 28: -#line 332 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 535 "./parse.y" {yyval.node = NULL;; break;} case 36: -#line 344 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 547 "./parse.y" { yyval.node = NULL; ; break;} case 37: -#line 348 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 551 "./parse.y" { yyval.node = NULL; ; break;} case 40: -#line 360 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 563 "./parse.y" { ctxp->package = EXPR_WFL_NODE (yyvsp[-1].node); ; break;} case 41: -#line 362 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 565 "./parse.y" {yyerror ("Missing name"); RECOVER;; break;} case 42: -#line 364 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 567 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} case 45: -#line 374 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 577 "./parse.y" { tree name = EXPR_WFL_NODE (yyvsp[-1].node), node, last_name; int i = IDENTIFIER_LENGTH (name)-1; @@ -2662,72 +2803,70 @@ case 45: (yyvsp[-1].node, "Ambiguous class: `%s' and `%s'", IDENTIFIER_POINTER (name), IDENTIFIER_POINTER (err)); + else + REGISTER_IMPORT (yyvsp[-1].node, last_name) } else - { - IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name) = 1; - node = build_tree_list (yyvsp[-1].node, last_name); - TREE_CHAIN (node) = ctxp->import_list; - ctxp->import_list = node; - } + REGISTER_IMPORT (yyvsp[-1].node, last_name); ; break;} case 46: -#line 403 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 603 "./parse.y" {yyerror ("Missing name"); RECOVER;; break;} case 47: -#line 405 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 605 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} case 48: -#line 410 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 610 "./parse.y" { tree name = EXPR_WFL_NODE (yyvsp[-3].node); - tree node = build_tree_list (yyvsp[-3].node, NULL_TREE); - if (!IS_AN_IMPORT_ON_DEMAND_P (name)) + /* Don't import java.lang.* twice. */ + if (name != java_lang_id) { + tree node = build_tree_list (yyvsp[-3].node, NULL_TREE); read_import_dir (yyvsp[-3].node); - IS_AN_IMPORT_ON_DEMAND_P (name) = 1; + TREE_CHAIN (node) = ctxp->import_demand_list; + ctxp->import_demand_list = node; } - TREE_CHAIN (node) = ctxp->import_demand_list; - ctxp->import_demand_list = node; ; break;} case 49: -#line 422 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 622 "./parse.y" {yyerror ("'*' expected"); RECOVER;; break;} case 50: -#line 424 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 624 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} case 51: -#line 429 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 629 "./parse.y" { + maybe_generate_finit (); maybe_generate_clinit (); yyval.node = yyvsp[0].node; ; break;} case 53: -#line 435 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 636 "./parse.y" { yyval.node = NULL; ; break;} case 54: -#line 437 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 638 "./parse.y" { YYERROR_NOW; yyerror ("Class or interface declaration expected"); ; break;} case 55: -#line 448 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 649 "./parse.y" { yyval.value = (1 << yyvsp[0].value); ; break;} case 56: -#line 452 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 653 "./parse.y" { int acc = (1 << yyvsp[0].value); if (yyval.value & acc) @@ -2741,107 +2880,124 @@ case 56: ; break;} case 57: -#line 468 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 669 "./parse.y" { create_class (yyvsp[-4].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; break;} case 58: -#line 470 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 671 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} case 59: -#line 474 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 675 "./parse.y" { create_class (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; break;} case 60: -#line 476 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 677 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} case 61: -#line 480 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 681 "./parse.y" {yyerror ("Missing class name"); RECOVER;; break;} case 62: -#line 482 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 683 "./parse.y" {yyerror ("Missing class name"); RECOVER;; break;} case 63: -#line 484 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{if (!ctxp->class_err) yyerror ("'{' expected"); DRECOVER(class1);; +#line 685 "./parse.y" +{ + if (!ctxp->class_err) yyerror ("'{' expected"); + DRECOVER(class1); + ; break;} case 64: -#line 486 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 690 "./parse.y" {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;; break;} case 65: -#line 490 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 694 "./parse.y" { yyval.node = NULL; ; break;} case 66: -#line 492 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 696 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} case 67: -#line 494 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 698 "./parse.y" {yyerror ("'{' expected"); ctxp->class_err=1;; break;} case 68: -#line 496 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 700 "./parse.y" {yyerror ("Missing super class name"); ctxp->class_err=1;; break;} case 69: -#line 500 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 704 "./parse.y" { yyval.node = NULL_TREE; ; break;} case 70: -#line 502 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 706 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} case 71: -#line 504 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 708 "./parse.y" { ctxp->class_err=1; yyerror ("Missing interface name"); ; break;} case 72: -#line 512 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 716 "./parse.y" { ctxp->interface_number = 1; yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); ; break;} case 73: -#line 517 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 721 "./parse.y" { ctxp->interface_number++; yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE)); ; break;} case 74: -#line 522 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 726 "./parse.y" {yyerror ("Missing interface name"); RECOVER;; break;} case 75: -#line 527 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 731 "./parse.y" { yyval.node = ctxp->current_parsed_class; ; break;} case 76: -#line 529 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 733 "./parse.y" { yyval.node = ctxp->current_parsed_class; ; break;} +case 82: +#line 746 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("instance initializer"); ; + break;} +case 84: +#line 752 "./parse.y" +{ yyval.node = yyvsp[-1].node; ; + break;} +case 86: +#line 755 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("inner classe declaration"); ; + break;} case 87: -#line 554 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ register_fields (0, yyvsp[-2].node, yyvsp[-1].node); ; +#line 757 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("inner interface declaration"); ; break;} case 88: -#line 556 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 763 "./parse.y" +{ register_fields (0, yyvsp[-2].node, yyvsp[-1].node); ; + break;} +case 89: +#line 765 "./parse.y" { - int acc_count = 0; - check_modifiers ("Illegal modifier `%s' for field declaration", yyvsp[-3].value, FIELD_MODIFIERS); @@ -2849,20 +3005,20 @@ case 88: register_fields (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node); ; break;} -case 90: -#line 571 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 91: +#line 778 "./parse.y" { yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node); ; break;} -case 91: -#line 573 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 92: +#line 780 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 92: -#line 578 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 93: +#line 785 "./parse.y" { yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); ; break;} -case 93: -#line 580 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 94: +#line 787 "./parse.y" { if (java_error_count) yyvsp[0].node = NULL_TREE; @@ -2870,411 +3026,454 @@ case 93: (yyvsp[-2].node, build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node)); ; break;} -case 94: -#line 587 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 95: +#line 794 "./parse.y" { yyerror ("Missing variable initializer"); yyval.node = build_tree_list (yyvsp[-2].node, NULL_TREE); RECOVER; ; break;} -case 95: -#line 593 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 96: +#line 800 "./parse.y" { yyerror ("';' expected"); yyval.node = build_tree_list (yyvsp[-3].node, NULL_TREE); RECOVER; ; break;} -case 97: -#line 603 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - yyval.node = NULL; /* FIXME */ - ; - break;} case 98: -#line 607 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Invalid declaration"); DRECOVER(vdi);; +#line 810 "./parse.y" +{ yyval.node = build_unresolved_array_type (yyvsp[-2].node); ; break;} case 99: -#line 609 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("']' expected"); DRECOVER(vdi);; +#line 812 "./parse.y" +{yyerror ("Invalid declaration"); DRECOVER(vdi);; break;} case 100: -#line 611 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Unbalanced ']'"); DRECOVER(vdi);; +#line 814 "./parse.y" +{yyerror ("']' expected"); DRECOVER(vdi);; break;} -case 102: -#line 617 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = NULL; ; +case 101: +#line 816 "./parse.y" +{yyerror ("Unbalanced ']'"); DRECOVER(vdi);; break;} -case 103: -#line 623 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 104: +#line 827 "./parse.y" { current_function_decl = yyvsp[0].node; source_start_java_method (current_function_decl); ; break;} -case 104: -#line 628 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - BLOCK_EXPR_BODY - (DECL_FUNCTION_BODY (current_function_decl)) = yyvsp[0].node; - maybe_absorb_scoping_blocks (); - exit_block (); /* Exit function's body. */ - - /* Merge last line of the function with first line, - directly in the function decl. It will be used to - emit correct debug info. */ - DECL_SOURCE_LINE_MERGE (current_function_decl, - ctxp->last_ccb_indent1); - ; - break;} case 105: -#line 641 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{YYNOT_TWICE yyerror ("'{' expected"); RECOVER;; +#line 832 "./parse.y" +{ finish_method_declaration (yyvsp[0].node); ; break;} case 106: -#line 646 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = method_header (0, yyvsp[-2].node, yyvsp[-1].node, NULL); ; +#line 834 "./parse.y" +{YYNOT_TWICE yyerror ("'{' expected"); RECOVER;; break;} case 107: -#line 648 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = method_header (0, void_type_node, yyvsp[-1].node, NULL); ; +#line 839 "./parse.y" +{ yyval.node = method_header (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; break;} case 108: -#line 650 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = method_header (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node, NULL); ; +#line 841 "./parse.y" +{ yyval.node = method_header (0, void_type_node, yyvsp[-1].node, yyvsp[0].node); ; break;} case 109: -#line 652 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = method_header (yyvsp[-3].value, void_type_node, yyvsp[-1].node, NULL); ; +#line 843 "./parse.y" +{ yyval.node = method_header (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; break;} case 110: -#line 654 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{RECOVER;; +#line 845 "./parse.y" +{ yyval.node = method_header (yyvsp[-3].value, void_type_node, yyvsp[-1].node, yyvsp[0].node); ; break;} case 111: -#line 656 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 847 "./parse.y" {RECOVER;; break;} case 112: -#line 658 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Identifier expected"); RECOVER;; +#line 849 "./parse.y" +{RECOVER;; break;} case 113: -#line 660 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 851 "./parse.y" {yyerror ("Identifier expected"); RECOVER;; break;} case 114: -#line 662 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 853 "./parse.y" +{yyerror ("Identifier expected"); RECOVER;; + break;} +case 115: +#line 855 "./parse.y" { yyerror ("Invalid method declaration, return type required"); RECOVER; ; break;} -case 115: -#line 670 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 116: +#line 863 "./parse.y" { yyval.node = method_declarator (yyvsp[-2].node, NULL_TREE); ; break;} -case 116: -#line 672 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 117: +#line 865 "./parse.y" { yyval.node = method_declarator (yyvsp[-3].node, yyvsp[-1].node); ; break;} -case 117: -#line 674 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - /* Issue a warning here: obsolete declaration. FIXME */ - yyval.node = NULL; /* FIXME */ +case 118: +#line 867 "./parse.y" +{ + EXPR_WFL_LINECOL (wfl_operator) = yyvsp[-1].operator.location; + TREE_PURPOSE (yyvsp[-2].node) = + build_unresolved_array_type (TREE_PURPOSE (yyvsp[-2].node)); + parse_warning_context + (wfl_operator, + "Discouraged form of returned type specification"); ; break;} -case 118: -#line 679 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 119: +#line 876 "./parse.y" {yyerror ("')' expected"); DRECOVER(method_declarator);; break;} -case 119: -#line 681 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 120: +#line 878 "./parse.y" {yyerror ("']' expected"); RECOVER;; break;} -case 120: -#line 686 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 121: +#line 883 "./parse.y" { ctxp->formal_parameter_number = 1; ; break;} -case 121: -#line 690 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 122: +#line 887 "./parse.y" { ctxp->formal_parameter_number += 1; yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node); ; break;} -case 122: -#line 695 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing formal parameter term"); RECOVER;; - break;} case 123: -#line 700 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - yyval.node = build_tree_list (yyvsp[0].node, yyvsp[-1].node); - ; +#line 892 "./parse.y" +{yyerror ("Missing formal parameter term"); RECOVER;; break;} case 124: -#line 704 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 897 "./parse.y" { - SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-2].value)); - yyval.node = NULL; /* FIXME */ + yyval.node = build_tree_list (yyvsp[0].node, yyvsp[-1].node); ; break;} case 125: -#line 709 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing identifier"); RECOVER;; +#line 901 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("final parameters"); ; break;} case 126: -#line 711 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 903 "./parse.y" +{yyerror ("Missing identifier"); RECOVER;; + break;} +case 127: +#line 905 "./parse.y" { SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-2].value)); yyerror ("Missing identifier"); RECOVER; ; break;} +case 128: +#line 912 "./parse.y" +{ yyval.node = NULL_TREE; ; + break;} case 129: -#line 720 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 914 "./parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 130: +#line 916 "./parse.y" {yyerror ("Missing class type term"); RECOVER;; break;} +case 131: +#line 921 "./parse.y" +{ yyval.node = build_tree_list (yyvsp[0].node, yyvsp[0].node); ; + break;} case 132: -#line 727 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing class type term"); RECOVER;; +#line 923 "./parse.y" +{ yyval.node = tree_cons (yyvsp[0].node, yyvsp[0].node, yyvsp[-2].node); ; break;} -case 135: -#line 734 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = NULL_TREE; ; +case 133: +#line 925 "./parse.y" +{yyerror ("Missing class type term"); RECOVER;; break;} case 136: -#line 740 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("STATIC_INITIALIZER"); - ; +#line 932 "./parse.y" +{ yyval.node = NULL_TREE; ; break;} case 137: -#line 744 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 938 "./parse.y" { - RULE ("STATIC_INITIALIZER"); + TREE_CHAIN (yyvsp[0].node) = ctxp->static_initialized; + ctxp->static_initialized = yyvsp[0].node; ; break;} case 138: -#line 751 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 943 "./parse.y" { - SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value)); + TREE_CHAIN (yyvsp[-1].node) = ctxp->static_initialized; + ctxp->static_initialized = yyvsp[-1].node; ; break;} case 139: -#line 763 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 951 "./parse.y" { - RULE ("CONSTRUCTOR_DECLARATION"); + SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value)); ; break;} case 140: -#line 767 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 959 "./parse.y" { - SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-3].value)); - RULE ("CONSTRUCTOR_DECLARATION (modifier)"); + current_function_decl = yyvsp[0].node; + source_start_java_method (current_function_decl); ; break;} case 141: -#line 773 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("CONSTRUCTOR_DECLARATION"); - ; +#line 964 "./parse.y" +{ finish_method_declaration (yyvsp[0].node); ; break;} case 142: -#line 778 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-4].value)); - RULE ("CONSTRUCTOR_DECLARATION (modifier)"); +#line 969 "./parse.y" +{ yyval.node = method_header (0, NULL_TREE, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 143: +#line 971 "./parse.y" +{ yyval.node = method_header (yyvsp[-2].value, NULL_TREE, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 144: +#line 976 "./parse.y" +{ yyval.node = method_declarator (yyvsp[-2].node, NULL_TREE); ; + break;} +case 145: +#line 978 "./parse.y" +{ yyval.node = method_declarator (yyvsp[-3].node, yyvsp[-1].node); ; + break;} +case 146: +#line 986 "./parse.y" +{ + BLOCK_EXPR_BODY (yyvsp[0].node) = empty_stmt_node; + yyval.node = yyvsp[0].node; + ; + break;} +case 147: +#line 991 "./parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 148: +#line 993 "./parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 149: +#line 995 "./parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 150: +#line 1001 "./parse.y" +{ + yyval.node = build_method_invocation (yyvsp[-3].node, NULL_TREE); + yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-3].node), yyval.node); + yyval.node = java_method_add_stmt (current_function_decl, yyval.node); + ; + break;} +case 151: +#line 1007 "./parse.y" +{ + yyval.node = build_method_invocation (yyvsp[-4].node, yyvsp[-2].node); + yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-4].node), yyval.node); + yyval.node = java_method_add_stmt (current_function_decl, yyval.node); ; break;} case 152: -#line 806 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{RULE ("explicit_constructor_invocation (X.super)");; +#line 1015 "./parse.y" +{yyval.node = parse_jdk1_1_error ("explicit constructor invocation"); ; break;} case 153: -#line 811 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1017 "./parse.y" +{yyval.node = parse_jdk1_1_error ("explicit constructor invocation"); ; + break;} +case 154: +#line 1022 "./parse.y" { - tree wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0); + tree wfl = build_wfl_node (this_identifier_node); EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location; yyval.node = wfl; ; break;} -case 154: -#line 817 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 155: +#line 1028 "./parse.y" { - tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0); + tree wfl = build_wfl_node (super_identifier_node); EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location; yyval.node = wfl; ; break;} -case 155: -#line 828 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 156: +#line 1039 "./parse.y" { create_interface (0, yyvsp[0].node, NULL_TREE); ; break;} -case 156: -#line 830 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 157: +#line 1041 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} -case 157: -#line 834 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 158: +#line 1045 "./parse.y" { create_interface (yyvsp[-2].value, yyvsp[0].node, NULL_TREE); ; break;} -case 158: -#line 836 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 159: +#line 1047 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} -case 159: -#line 840 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 160: +#line 1051 "./parse.y" { create_interface (0, yyvsp[-1].node, yyvsp[0].node); ; break;} -case 160: -#line 842 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 161: +#line 1053 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} -case 161: -#line 846 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 162: +#line 1057 "./parse.y" { create_interface (yyvsp[-3].value, yyvsp[-1].node, yyvsp[0].node); ; break;} -case 162: -#line 848 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 163: +#line 1059 "./parse.y" { yyval.node = yyvsp[0].node; ; break;} -case 163: -#line 852 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("(here)'{' expected"); RECOVER;; - break;} case 164: -#line 854 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("(there)'{' expected"); RECOVER;; +#line 1063 "./parse.y" +{yyerror ("'{' expected"); RECOVER;; break;} case 165: -#line 859 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1065 "./parse.y" +{yyerror ("'{' expected"); RECOVER;; + break;} +case 166: +#line 1070 "./parse.y" { ctxp->interface_number = 1; yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); ; break;} -case 166: -#line 864 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 167: +#line 1075 "./parse.y" { ctxp->interface_number++; yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE)); ; break;} -case 167: -#line 869 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 168: +#line 1080 "./parse.y" {yyerror ("Invalid interface type"); RECOVER;; break;} -case 168: -#line 871 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 169: +#line 1082 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 169: -#line 876 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 170: +#line 1087 "./parse.y" { yyval.node = NULL_TREE; ; break;} -case 170: -#line 878 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 171: +#line 1089 "./parse.y" { yyval.node = NULL_TREE; ; break;} -case 178: -#line 899 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 176: +#line 1101 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class declaration"); ; + break;} +case 177: +#line 1103 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("inner interface declaration"); ; + break;} +case 179: +#line 1112 "./parse.y" { check_abstract_method_header (yyvsp[-1].node); current_function_decl = NULL_TREE; /* FIXME ? */ ; break;} -case 179: -#line 904 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("';' expected"); RECOVER;; - break;} case 180: -#line 910 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("ARRAY_INITIALIZER (empty)"); - ; +#line 1117 "./parse.y" +{yyerror ("';' expected"); RECOVER;; break;} case 181: -#line 914 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("ARRAY_INITIALIZER (variable)"); - ; +#line 1123 "./parse.y" +{ yyval.node = build_new_array_init (yyvsp[-1].operator.location, NULL_TREE); ; break;} case 182: -#line 918 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("ARRAY_INITIALIZER (,)"); - ; +#line 1125 "./parse.y" +{ yyval.node = build_new_array_init (yyvsp[-2].operator.location, yyvsp[-1].node); ; break;} case 183: -#line 922 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1127 "./parse.y" +{ yyval.node = build_new_array_init (yyvsp[-3].operator.location, yyvsp[-2].node); ; + break;} +case 184: +#line 1132 "./parse.y" +{ + yyval.node = tree_cons (maybe_build_array_element_wfl (yyvsp[0].node), + yyvsp[0].node, NULL_TREE); + ; + break;} +case 185: +#line 1137 "./parse.y" { - RULE ("ARRAY_INITIALIZER (variable, ,)"); + yyval.node = tree_cons (maybe_build_array_element_wfl (yyvsp[0].node), yyvsp[0].node, yyvsp[-2].node); ; break;} case 186: -#line 931 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1141 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} case 187: -#line 937 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = size_zero_node; ; +#line 1147 "./parse.y" +{ yyval.node = empty_stmt_node; ; break;} case 188: -#line 939 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ enter_block (); ; +#line 1149 "./parse.y" +{ yyval.node = yyvsp[0].node; ; break;} case 189: -#line 942 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1154 "./parse.y" +{ enter_block (); ; + break;} +case 190: +#line 1159 "./parse.y" { maybe_absorb_scoping_blocks (); yyval.node = exit_block (); ; break;} -case 193: -#line 956 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = java_method_add_stmt (current_function_decl, yyvsp[0].node); ; +case 194: +#line 1173 "./parse.y" +{ java_method_add_stmt (current_function_decl, yyvsp[0].node); ; break;} -case 196: -#line 966 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ declare_local_variables (0, yyvsp[-1].node, yyvsp[0].node); ; +case 195: +#line 1175 "./parse.y" +{ parse_jdk1_1_error ("inner class declaration"); ; break;} case 197: -#line 968 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ declare_local_variables (yyvsp[-2].value, yyvsp[-1].node, yyvsp[0].node); ; - break;} -case 199: -#line 974 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (labeled)"); ; - break;} -case 200: -#line 976 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (if-then)"); ; - break;} -case 201: -#line 978 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (if-then-else)"); ; +#line 1184 "./parse.y" +{ declare_local_variables (0, yyvsp[-1].node, yyvsp[0].node); ; break;} -case 202: -#line 980 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (while)"); ; +case 198: +#line 1186 "./parse.y" +{ declare_local_variables (yyvsp[-2].value, yyvsp[-1].node, yyvsp[0].node); ; break;} -case 203: -#line 982 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 204: +#line 1196 "./parse.y" { /* If the for loop is unlabeled, we must return the block it was defined it. It our last chance to @@ -3283,98 +3482,34 @@ case 203: yyval.node = exit_block (); ; break;} -case 205: -#line 994 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("NSI STATEMENT (labeled)"); ; - break;} -case 206: -#line 996 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("NSI STATEMENT (if-then-else)"); ; - break;} -case 207: -#line 998 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("NSI STATEMENT (while)"); ; - break;} -case 208: -#line 1000 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("NSI STATEMENT (for)"); ; - break;} -case 209: -#line 1005 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (block)"); ; - break;} -case 210: -#line 1007 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (empty)"); ; - break;} -case 211: -#line 1009 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (expression)"); ; - break;} -case 212: -#line 1011 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (switch)"); ; - break;} -case 213: -#line 1013 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (do)"); ; - break;} -case 214: -#line 1015 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (break)"); ; - break;} -case 215: -#line 1017 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (continue)"); ; - break;} -case 217: -#line 1020 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (synchronized)"); ; - break;} -case 218: -#line 1022 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (throw)"); ; - break;} -case 219: -#line 1024 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ RULE ("STATEMENT (try)"); ; - break;} -case 220: -#line 1029 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = size_zero_node; ; - break;} case 221: -#line 1034 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1229 "./parse.y" +{ yyval.node = empty_stmt_node; ; + break;} +case 222: +#line 1234 "./parse.y" { yyval.node = build_labeled_block (EXPR_WFL_LINECOL (yyvsp[-1].node), - EXPR_WFL_NODE (yyvsp[-1].node), yyvsp[-1].node); + EXPR_WFL_NODE (yyvsp[-1].node)); pushlevel (2); push_labeled_block (yyval.node); PUSH_LABELED_BLOCK (yyval.node); ; break;} -case 222: -#line 1045 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - yyval.node = complete_labeled_statement (yyvsp[-1].node, yyvsp[0].node); - pop_labeled_block (); - POP_LABELED_BLOCK (); - ; - break;} case 223: -#line 1051 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("':' expected"); RECOVER;; +#line 1245 "./parse.y" +{ yyval.node = finish_labeled_statement (yyvsp[-1].node, yyvsp[0].node); ; break;} case 224: -#line 1056 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - yyval.node = complete_labeled_statement (yyvsp[-1].node, yyvsp[0].node); - pop_labeled_block (); - POP_LABELED_BLOCK (); - ; +#line 1247 "./parse.y" +{yyerror ("':' expected"); RECOVER;; break;} case 225: -#line 1067 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1252 "./parse.y" +{ yyval.node = finish_labeled_statement (yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 226: +#line 1259 "./parse.y" { /* We have a statement. Generate a WFL around it so we can debug it */ @@ -3384,238 +3519,275 @@ case 225: yyval.node = JAVA_MAYBE_GENERATE_DEBUG_INFO (yyval.node); ; break;} -case 226: -#line 1076 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 227: +#line 1268 "./parse.y" { if (ctxp->prevent_ese != lineno) yyerror ("Invalid expression statement"); DRECOVER (expr_stmt); ; break;} -case 227: -#line 1082 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 228: +#line 1274 "./parse.y" { if (ctxp->prevent_ese != lineno) yyerror ("Invalid expression statement"); DRECOVER (expr_stmt); ; break;} -case 228: -#line 1088 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 229: +#line 1280 "./parse.y" { if (ctxp->prevent_ese != lineno) yyerror ("Invalid expression statement"); DRECOVER (expr_stmt); ; break;} -case 229: -#line 1094 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("')' expected"); RECOVER;; - break;} case 230: -#line 1096 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("';' expected"); RECOVER;; +#line 1286 "./parse.y" +{yyerror ("')' expected"); RECOVER;; break;} case 231: -#line 1098 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("')' expected"); RECOVER;; +#line 1288 "./parse.y" +{ + yyerror ("Constructor invocation must be first " + "thing in a constructor"); + RECOVER; + ; break;} case 232: -#line 1100 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("';' expected"); RECOVER;; +#line 1294 "./parse.y" +{yyerror ("')' expected"); RECOVER;; break;} case 233: -#line 1102 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'(' expected"); RECOVER;; +#line 1296 "./parse.y" +{ + yyerror ("Constructor invocation must be first " + "thing in a constructor"); + RECOVER; + ; break;} case 234: -#line 1104 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("')' expected"); RECOVER;; +#line 1302 "./parse.y" +{yyerror ("'(' expected"); RECOVER;; break;} case 235: -#line 1106 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1304 "./parse.y" {yyerror ("')' expected"); RECOVER;; break;} case 236: -#line 1108 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("';' expected"); RECOVER;; +#line 1306 "./parse.y" +{yyerror ("')' expected"); RECOVER;; break;} case 237: -#line 1110 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1308 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} -case 239: -#line 1116 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("++INCREMENT"); - ; - break;} -case 240: -#line 1120 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("--DECREMENT"); - ; - break;} -case 241: -#line 1124 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("INCREMENT++"); - ; - break;} -case 242: -#line 1128 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("DECREMENT--"); - ; +case 238: +#line 1310 "./parse.y" +{yyerror ("';' expected"); RECOVER;; break;} -case 244: -#line 1133 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - RULE ("INSTANCE CREATION"); +case 246: +#line 1325 "./parse.y" +{ + yyval.node = build_if_else_statement (yyvsp[-3].operator.location, yyvsp[-2].node, + yyvsp[0].node, NULL_TREE); ; break;} -case 245: -#line 1140 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = build_if_else_statement (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node, NULL_TREE); ; - break;} -case 246: -#line 1142 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 247: +#line 1330 "./parse.y" {yyerror ("'(' expected"); RECOVER;; break;} -case 247: -#line 1144 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 248: +#line 1332 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 248: -#line 1146 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 249: +#line 1334 "./parse.y" {yyerror ("')' expected"); RECOVER;; break;} -case 249: -#line 1151 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 250: +#line 1339 "./parse.y" { yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 250: -#line 1156 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 251: +#line 1344 "./parse.y" { yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ; break;} case 252: -#line 1162 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'(' expected"); RECOVER;; +#line 1349 "./parse.y" +{ + enter_block (); + ; break;} case 253: -#line 1164 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing term or ')'"); DRECOVER(switch_statement);; +#line 1353 "./parse.y" +{ + /* Make into "proper list" of COMPOUND_EXPRs. + I.e. make the last statment also have its own + COMPOUND_EXPR. */ + maybe_absorb_scoping_blocks (); + TREE_OPERAND (yyvsp[-2].node, 1) = exit_block (); + yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-2].node), yyvsp[-2].node); + ; break;} case 254: -#line 1166 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1365 "./parse.y" +{ + yyval.node = build (SWITCH_EXPR, NULL_TREE, yyvsp[-1].node, NULL_TREE); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-2].operator.location; + ; + break;} +case 255: +#line 1370 "./parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 256: +#line 1372 "./parse.y" +{yyerror ("Missing term or ')'"); DRECOVER(switch_statement);; + break;} +case 257: +#line 1374 "./parse.y" {yyerror ("'{' expected"); RECOVER;; break;} -case 266: -#line 1195 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing or invalid constant expression"); RECOVER;; +case 258: +#line 1382 "./parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 259: +#line 1384 "./parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 260: +#line 1386 "./parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 261: +#line 1388 "./parse.y" +{ yyval.node = NULL_TREE; ; break;} case 267: -#line 1197 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("':' expected"); RECOVER;; +#line 1407 "./parse.y" +{ + tree lab = build1 (CASE_EXPR, NULL_TREE, yyvsp[-1].node); + EXPR_WFL_LINECOL (lab) = yyvsp[-2].operator.location; + java_method_add_stmt (current_function_decl, lab); + ; break;} case 268: -#line 1199 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("':' expected"); RECOVER;; +#line 1413 "./parse.y" +{ + tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE); + EXPR_WFL_LINECOL (lab) = yyvsp[-1].operator.location; + java_method_add_stmt (current_function_decl, lab); + ; break;} case 269: -#line 1204 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1419 "./parse.y" +{yyerror ("Missing or invalid constant expression"); RECOVER;; + break;} +case 270: +#line 1421 "./parse.y" +{yyerror ("':' expected"); RECOVER;; + break;} +case 271: +#line 1423 "./parse.y" +{yyerror ("':' expected"); RECOVER;; + break;} +case 272: +#line 1428 "./parse.y" { tree body = build_loop_body (yyvsp[-2].operator.location, yyvsp[-1].node, 0); yyval.node = build_new_loop (body); ; break;} -case 270: -#line 1212 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = complete_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ; +case 273: +#line 1436 "./parse.y" +{ yyval.node = finish_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ; break;} -case 271: -#line 1214 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 274: +#line 1438 "./parse.y" {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;; break;} -case 272: -#line 1216 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 275: +#line 1440 "./parse.y" {yyerror ("Missing term and ')' expected"); RECOVER;; break;} -case 273: -#line 1218 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 276: +#line 1442 "./parse.y" {yyerror ("')' expected"); RECOVER;; break;} -case 274: -#line 1223 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = complete_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ; +case 277: +#line 1447 "./parse.y" +{ yyval.node = finish_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ; break;} -case 275: -#line 1228 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 278: +#line 1452 "./parse.y" { tree body = build_loop_body (0, NULL_TREE, 1); yyval.node = build_new_loop (body); ; break;} -case 276: -#line 1237 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = complete_loop_body (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[-5].node, 1); ; +case 279: +#line 1461 "./parse.y" +{ yyval.node = finish_loop_body (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[-5].node, 1); ; break;} -case 277: -#line 1242 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = complete_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);; +case 280: +#line 1466 "./parse.y" +{ yyval.node = finish_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 278: -#line 1244 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 281: +#line 1468 "./parse.y" { - yyval.node = complete_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node); + yyval.node = finish_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node); /* We have not condition, so we get rid of the EXIT_EXPR */ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY (yyval.node), 0) = - size_zero_node; + empty_stmt_node; ; break;} -case 279: -#line 1251 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 282: +#line 1475 "./parse.y" {yyerror ("Invalid control expression"); RECOVER;; break;} -case 280: -#line 1253 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 283: +#line 1477 "./parse.y" {yyerror ("Invalid update expression"); RECOVER;; break;} -case 281: -#line 1255 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 284: +#line 1479 "./parse.y" {yyerror ("Invalid update expression"); RECOVER;; break;} -case 282: -#line 1260 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = complete_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);; +case 285: +#line 1484 "./parse.y" +{ yyval.node = finish_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);; break;} -case 283: -#line 1262 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 286: +#line 1486 "./parse.y" { - yyval.node = complete_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node); + yyval.node = finish_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node); /* We have not condition, so we get rid of the EXIT_EXPR */ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY (yyval.node), 0) = - size_zero_node; + empty_stmt_node; ; break;} -case 284: -#line 1272 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 287: +#line 1496 "./parse.y" { /* This scope defined for local variable that may be defined within the scope of the for loop */ enter_block (); ; break;} -case 285: -#line 1278 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 288: +#line 1502 "./parse.y" {yyerror ("'(' expected"); DRECOVER(for_1);; break;} -case 286: -#line 1280 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 289: +#line 1504 "./parse.y" {yyerror ("Invalid init statement"); RECOVER;; break;} -case 287: -#line 1285 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 290: +#line 1509 "./parse.y" { /* We now declare the loop body. The loop is declared as a for loop. */ @@ -3627,489 +3799,599 @@ case 287: java_method_add_stmt (current_function_decl, yyval.node); ; break;} -case 288: -#line 1297 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = size_zero_node; ; +case 291: +#line 1521 "./parse.y" +{ yyval.node = empty_stmt_node; ; break;} -case 289: -#line 1299 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 292: +#line 1523 "./parse.y" { /* Init statement recorded within the previously defined block scope */ yyval.node = java_method_add_stmt (current_function_decl, yyvsp[0].node); ; break;} -case 290: -#line 1305 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 293: +#line 1529 "./parse.y" { /* Local variable are recorded within the previously defined block scope */ yyval.node = NULL_TREE; ; break;} -case 291: -#line 1311 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 294: +#line 1535 "./parse.y" {yyerror ("';' expected"); DRECOVER(for_init_1);; break;} -case 292: -#line 1315 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyval.node = size_zero_node;; +case 295: +#line 1539 "./parse.y" +{yyval.node = empty_stmt_node;; break;} -case 293: -#line 1317 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 296: +#line 1541 "./parse.y" { yyval.node = build_debugable_stmt (BUILD_LOCATION (), yyvsp[0].node); ; break;} -case 294: -#line 1322 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 297: +#line 1546 "./parse.y" { yyval.node = add_stmt_to_compound (NULL_TREE, NULL_TREE, yyvsp[0].node); ; break;} -case 295: -#line 1324 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 298: +#line 1548 "./parse.y" { yyval.node = add_stmt_to_compound (yyvsp[-2].node, NULL_TREE, yyvsp[0].node); ; break;} -case 296: -#line 1326 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 299: +#line 1550 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 297: -#line 1331 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 300: +#line 1555 "./parse.y" { yyval.node = build_bc_statement (yyvsp[-1].operator.location, 1, NULL_TREE); ; break;} -case 298: -#line 1333 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 301: +#line 1557 "./parse.y" { yyval.node = build_bc_statement (yyvsp[-2].operator.location, 1, yyvsp[-1].node); ; break;} -case 299: -#line 1335 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 302: +#line 1559 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 300: -#line 1337 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 303: +#line 1561 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} -case 301: -#line 1342 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 304: +#line 1566 "./parse.y" { yyval.node = build_bc_statement (yyvsp[-1].operator.location, 0, NULL_TREE); ; break;} -case 302: -#line 1344 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 305: +#line 1568 "./parse.y" { yyval.node = build_bc_statement (yyvsp[-2].operator.location, 0, yyvsp[-1].node); ; break;} -case 303: -#line 1346 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 306: +#line 1570 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 304: -#line 1348 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 307: +#line 1572 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} -case 305: -#line 1353 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 308: +#line 1577 "./parse.y" { yyval.node = build_return (yyvsp[-1].operator.location, NULL_TREE); ; break;} -case 306: -#line 1355 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 309: +#line 1579 "./parse.y" { yyval.node = build_return (yyvsp[-2].operator.location, yyvsp[-1].node); ; break;} -case 307: -#line 1357 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 310: +#line 1581 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 308: -#line 1359 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 311: +#line 1583 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} -case 310: -#line 1365 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 312: +#line 1588 "./parse.y" +{ + yyval.node = build1 (THROW_EXPR, NULL_TREE, yyvsp[-1].node); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-2].operator.location; + ; + break;} +case 313: +#line 1593 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 311: -#line 1367 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 314: +#line 1595 "./parse.y" {yyerror ("';' expected"); RECOVER;; break;} -case 313: -#line 1373 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 315: +#line 1600 "./parse.y" +{ + yyval.node = build (SYNCHRONIZED_EXPR, NULL_TREE, yyvsp[-2].node, yyvsp[0].node); + EXPR_WFL_LINECOL (yyval.node) = + EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK)); + ; + break;} +case 316: +#line 1606 "./parse.y" {yyerror ("'{' expected"); RECOVER;; break;} -case 314: -#line 1375 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 317: +#line 1608 "./parse.y" {yyerror ("'(' expected"); RECOVER;; break;} -case 315: -#line 1377 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 318: +#line 1610 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 316: -#line 1379 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 319: +#line 1612 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 317: -#line 1384 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 320: +#line 1617 "./parse.y" { - SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value)); + if ((1 << yyvsp[0].value) != ACC_SYNCHRONIZED) + fatal ("synchronized was '%d' - yyparse", (1 << yyvsp[0].value)); ; break;} case 321: -#line 1394 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'{' expected"); DRECOVER (try_statement);; +#line 1625 "./parse.y" +{ yyval.node = build_try_statement (yyvsp[-2].operator.location, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 322: +#line 1627 "./parse.y" +{ yyval.node = build_try_finally_statement (yyvsp[-2].operator.location, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 323: +#line 1629 "./parse.y" +{ yyval.node = build_try_finally_statement + (yyvsp[-3].operator.location, build_try_statement (yyvsp[-3].operator.location, + yyvsp[-2].node, yyvsp[-1].node), yyvsp[0].node); + ; break;} -case 325: -#line 1405 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'(' expected"); RECOVER;; +case 324: +#line 1634 "./parse.y" +{yyerror ("'{' expected"); DRECOVER (try_statement);; break;} case 326: -#line 1407 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing term"); DRECOVER (1);; +#line 1640 "./parse.y" +{ + TREE_CHAIN (yyvsp[0].node) = yyvsp[-1].node; + yyval.node = yyvsp[0].node; + ; break;} case 327: -#line 1409 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("Missing term"); DRECOVER (2);; +#line 1648 "./parse.y" +{ + java_method_add_stmt (current_function_decl, yyvsp[0].node); + exit_block (); + yyval.node = yyvsp[-1].node; + ; + break;} +case 328: +#line 1656 "./parse.y" +{ + /* We add a block to define a scope for + formal_parameter (CCBP). The formal parameter is + declared initialized by the appropriate function + call */ + tree ccpb = enter_block (); + tree init = build_assignment (ASSIGN_TK, yyvsp[-2].operator.location, + TREE_PURPOSE (yyvsp[-1].node), + soft_exceptioninfo_call_node); + declare_local_variables (0, TREE_VALUE (yyvsp[-1].node), + build_tree_list (TREE_PURPOSE (yyvsp[-1].node), + init)); + yyval.node = build1 (CATCH_EXPR, NULL_TREE, ccpb); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-3].operator.location; + ; break;} case 329: -#line 1415 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'{' expected"); RECOVER; ; +#line 1672 "./parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 330: +#line 1674 "./parse.y" +{yyerror ("Missing term or ')' expected"); DRECOVER (2);; + break;} +case 331: +#line 1676 "./parse.y" +{yyerror ("')' expected"); DRECOVER (1);; + break;} +case 332: +#line 1681 "./parse.y" +{ yyval.node = yyvsp[0].node; ; break;} case 333: -#line 1427 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 1683 "./parse.y" +{yyerror ("'{' expected"); RECOVER; ; + break;} +case 337: +#line 1695 "./parse.y" { yyval.node = build_this (yyvsp[0].operator.location); ; break;} -case 334: -#line 1429 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 338: +#line 1697 "./parse.y" {yyval.node = yyvsp[-1].node;; break;} case 343: -#line 1445 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("')' expected"); RECOVER;; +#line 1706 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("named class literals"); ; break;} case 344: -#line 1447 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'class' or 'this' expected" ); RECOVER;; +#line 1708 "./parse.y" +{ yyval.node = build_class_ref (yyvsp[-2].node); ; break;} case 345: -#line 1449 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'class' expected" ); RECOVER;; +#line 1710 "./parse.y" +{ yyval.node = build_class_ref (void_type_node); ; break;} case 346: -#line 1451 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyerror ("'class' expected" ); RECOVER;; +#line 1715 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("class literals"); ; break;} case 347: -#line 1456 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - yyval.node = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); - TREE_SET_CODE (yyval.node, JAVA_NEW_CLASS_EXPR); - ; +#line 1717 "./parse.y" +{yyerror ("')' expected"); RECOVER;; break;} case 348: -#line 1461 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - yyval.node = build_method_invocation (yyvsp[-2].node, NULL_TREE); - TREE_SET_CODE (yyval.node, JAVA_NEW_CLASS_EXPR); - ; +#line 1719 "./parse.y" +{yyerror ("'class' or 'this' expected" ); RECOVER;; break;} case 349: -#line 1469 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyval.node = yyvsp[-4].node;; +#line 1721 "./parse.y" +{yyerror ("'class' expected" ); RECOVER;; break;} case 350: -#line 1471 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyval.node = yyvsp[-3].node;; +#line 1723 "./parse.y" +{yyerror ("'class' expected" ); RECOVER;; + break;} +case 351: +#line 1728 "./parse.y" +{ yyval.node = build_new_invocation (yyvsp[-3].node, yyvsp[-1].node); ; break;} -case 355: -#line 1480 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 352: +#line 1730 "./parse.y" +{ yyval.node = build_new_invocation (yyvsp[-2].node, NULL_TREE); ; + break;} +case 353: +#line 1735 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class instance creation"); ; + break;} +case 354: +#line 1737 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class instance creation"); ; + break;} +case 359: +#line 1746 "./parse.y" {yyerror ("'(' expected"); DRECOVER(new_1);; break;} -case 356: -#line 1482 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 360: +#line 1748 "./parse.y" {yyerror ("'(' expected"); RECOVER;; break;} -case 357: -#line 1484 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 361: +#line 1750 "./parse.y" {yyerror ("')' or term expected"); RECOVER;; break;} -case 358: -#line 1486 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 362: +#line 1752 "./parse.y" {yyerror ("')' expected"); RECOVER;; break;} -case 359: -#line 1488 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 363: +#line 1754 "./parse.y" {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;; break;} -case 360: -#line 1490 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 364: +#line 1756 "./parse.y" {yyerror ("'(' expected"); RECOVER;; break;} -case 363: -#line 1500 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 367: +#line 1766 "./parse.y" { yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, NULL_TREE); ctxp->formal_parameter_number = 1; ; break;} -case 364: -#line 1505 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 368: +#line 1771 "./parse.y" { ctxp->formal_parameter_number += 1; yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyvsp[-2].node); ; break;} -case 365: -#line 1510 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 369: +#line 1776 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 366: -#line 1515 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 370: +#line 1781 "./parse.y" { yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); ; break;} -case 367: -#line 1517 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 371: +#line 1783 "./parse.y" { yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); ; break;} -case 368: -#line 1519 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, ctxp->osb_number); ; +case 372: +#line 1785 "./parse.y" +{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, CURRENT_OSB (ctxp));; break;} -case 369: -#line 1521 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, ctxp->osb_number); ; +case 373: +#line 1787 "./parse.y" +{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, CURRENT_OSB (ctxp));; break;} -case 370: -#line 1525 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyval.node = yyvsp[-2].node;; +case 374: +#line 1791 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("anonymous array"); ; break;} -case 371: -#line 1527 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{yyval.node = yyvsp[-2].node;; +case 375: +#line 1793 "./parse.y" +{ yyval.node = parse_jdk1_1_error ("anonymous array"); ; break;} -case 372: -#line 1529 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 376: +#line 1795 "./parse.y" {yyerror ("'[' expected"); DRECOVER ("]");; break;} -case 373: -#line 1531 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 377: +#line 1797 "./parse.y" {yyerror ("']' expected"); RECOVER;; break;} -case 374: -#line 1536 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 378: +#line 1802 "./parse.y" { yyval.node = build_tree_list (NULL_TREE, yyvsp[0].node); ; break;} -case 375: -#line 1538 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 379: +#line 1804 "./parse.y" { yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyval.node); ; break;} -case 376: -#line 1543 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 380: +#line 1809 "./parse.y" { EXPR_WFL_LINECOL (yyvsp[-1].node) = yyvsp[-2].operator.location; yyval.node = yyvsp[-1].node; ; break;} -case 377: -#line 1548 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 381: +#line 1814 "./parse.y" {yyerror ("']' expected"); RECOVER;; break;} -case 378: -#line 1550 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 382: +#line 1816 "./parse.y" { yyerror ("Missing term"); yyerror ("']' expected"); RECOVER; ; break;} -case 379: -#line 1559 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ ctxp->osb_number = 1; ; +case 383: +#line 1825 "./parse.y" +{ + int allocate = 0; + /* If not initialized, allocate memory for the osb + numbers stack */ + if (!ctxp->osb_limit) + { + allocate = ctxp->osb_limit = 32; + ctxp->osb_depth = -1; + } + /* If capacity overflown, reallocate a bigger chuck */ + else if (ctxp->osb_depth+1 == ctxp->osb_limit) + allocate = ctxp->osb_limit << 1; + + if (allocate) + { + allocate *= sizeof (int); + if (ctxp->osb_number) + ctxp->osb_number = (int *)xrealloc (ctxp->osb_number, + allocate); + else + ctxp->osb_number = (int *)xmalloc (allocate); + } + ctxp->osb_depth++; + CURRENT_OSB (ctxp) = 1; + ; break;} -case 380: -#line 1561 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ ctxp->osb_number++; ; +case 384: +#line 1851 "./parse.y" +{ CURRENT_OSB (ctxp)++; ; break;} -case 381: -#line 1563 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 385: +#line 1853 "./parse.y" { yyerror ("']' expected"); RECOVER;; break;} -case 382: -#line 1568 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 386: +#line 1858 "./parse.y" { yyval.node = make_qualified_primary (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); ; break;} -case 383: -#line 1570 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 387: +#line 1862 "./parse.y" { tree super_wfl = - build_wfl_node (super_identifier_node, input_filename, 0, 0); + build_wfl_node (super_identifier_node); EXPR_WFL_LINECOL (super_wfl) = yyvsp[-2].operator.location; yyval.node = make_qualified_name (super_wfl, yyvsp[0].node, yyvsp[-1].operator.location); ; break;} -case 384: -#line 1577 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 388: +#line 1869 "./parse.y" {yyerror ("Field expected"); DRECOVER (super_field_acces);; break;} -case 385: -#line 1582 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 389: +#line 1874 "./parse.y" { yyval.node = build_method_invocation (yyvsp[-2].node, NULL_TREE); ; break;} -case 386: -#line 1584 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 390: +#line 1876 "./parse.y" { yyval.node = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); ; break;} -case 387: -#line 1586 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 391: +#line 1878 "./parse.y" { - tree invok = build_method_invocation (yyvsp[-2].node, NULL_TREE); - yyval.node = make_qualified_primary (yyvsp[-4].node, invok, yyvsp[-3].operator.location); + if (TREE_CODE (yyvsp[-4].node) == THIS_EXPR) + yyval.node = build_this_super_qualified_invocation + (1, yyvsp[-2].node, NULL_TREE, 0, yyvsp[-3].operator.location); + else + { + tree invok = build_method_invocation (yyvsp[-2].node, NULL_TREE); + yyval.node = make_qualified_primary (yyvsp[-4].node, invok, yyvsp[-3].operator.location); + } ; break;} -case 388: -#line 1591 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 392: +#line 1889 "./parse.y" { - tree invok = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); - yyval.node = make_qualified_primary (yyvsp[-5].node, invok, yyvsp[-4].operator.location); + if (TREE_CODE (yyvsp[-5].node) == THIS_EXPR) + yyval.node = build_this_super_qualified_invocation + (1, yyvsp[-3].node, yyvsp[-1].node, 0, yyvsp[-4].operator.location); + else + { + tree invok = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); + yyval.node = make_qualified_primary (yyvsp[-5].node, invok, yyvsp[-4].operator.location); + } ; break;} -case 389: -#line 1596 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" -{ - tree invok; - tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0); - EXPR_WFL_LINECOL (wfl) = yyvsp[-4].operator.location; - invok = build_method_invocation (yyvsp[-2].node, NULL_TREE); - yyval.node = make_qualified_primary (wfl, invok, yyvsp[-3].operator.location); +case 393: +#line 1900 "./parse.y" +{ + yyval.node = build_this_super_qualified_invocation + (0, yyvsp[-2].node, NULL_TREE, yyvsp[-4].operator.location, yyvsp[-3].operator.location); ; break;} -case 390: -#line 1604 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 394: +#line 1905 "./parse.y" { - tree invok; - tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0); - EXPR_WFL_LINECOL (wfl) = yyvsp[-5].operator.location; - invok = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); - yyval.node = make_qualified_primary (wfl, invok, yyvsp[-4].operator.location); + yyval.node = build_this_super_qualified_invocation + (0, yyvsp[-3].node, yyvsp[-1].node, yyvsp[-5].operator.location, yyvsp[-4].operator.location); ; break;} -case 391: -#line 1616 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 395: +#line 1914 "./parse.y" { yyerror ("'(' expected"); DRECOVER (method_invocation); ; break;} -case 392: -#line 1618 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 396: +#line 1916 "./parse.y" { yyerror ("'(' expected"); DRECOVER (method_invocation); ; break;} -case 393: -#line 1623 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 397: +#line 1921 "./parse.y" { yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); ; break;} -case 394: -#line 1625 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 398: +#line 1923 "./parse.y" { yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); ; break;} -case 395: -#line 1627 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 399: +#line 1925 "./parse.y" { yyerror ("Missing term and ']' expected"); DRECOVER(array_access); ; break;} -case 396: -#line 1632 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 400: +#line 1930 "./parse.y" { yyerror ("']' expected"); DRECOVER(array_access); ; break;} -case 397: -#line 1637 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 401: +#line 1935 "./parse.y" { yyerror ("Missing term and ']' expected"); DRECOVER(array_access); ; break;} -case 398: -#line 1642 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 402: +#line 1940 "./parse.y" { yyerror ("']' expected"); DRECOVER(array_access); ; break;} -case 403: -#line 1657 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 407: +#line 1955 "./parse.y" { yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); ; break;} -case 404: -#line 1662 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 408: +#line 1960 "./parse.y" { yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); ; break;} -case 407: -#line 1669 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 411: +#line 1967 "./parse.y" {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; break;} -case 408: -#line 1671 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 412: +#line 1969 "./parse.y" {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; break;} -case 410: -#line 1674 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 414: +#line 1972 "./parse.y" {yyerror ("Missing term"); RECOVER; break;} -case 411: -#line 1676 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 415: +#line 1974 "./parse.y" {yyerror ("Missing term"); RECOVER; break;} -case 412: -#line 1681 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 416: +#line 1979 "./parse.y" {yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); ; break;} -case 413: -#line 1683 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 417: +#line 1981 "./parse.y" {yyerror ("Missing term"); RECOVER; break;} -case 414: -#line 1688 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 418: +#line 1986 "./parse.y" {yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); ; break;} -case 415: -#line 1690 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 419: +#line 1988 "./parse.y" {yyerror ("Missing term"); RECOVER; break;} -case 417: -#line 1696 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 421: +#line 1994 "./parse.y" {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; break;} -case 418: -#line 1698 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 422: +#line 1996 "./parse.y" {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; break;} -case 420: -#line 1701 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 424: +#line 1999 "./parse.y" {yyerror ("Missing term"); RECOVER; break;} -case 421: -#line 1703 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 425: +#line 2001 "./parse.y" {yyerror ("Missing term"); RECOVER; break;} -case 422: -#line 1708 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 426: +#line 2006 "./parse.y" { tree type = yyvsp[-3].node; - while (ctxp->osb_number--) + while (CURRENT_OSB (ctxp)--) type = build_java_array_type (type, -1); + ctxp->osb_depth--; yyval.node = build_cast (yyvsp[-4].operator.location, type, yyvsp[0].node); ; break;} -case 423: -#line 1715 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 427: +#line 2014 "./parse.y" { yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 424: -#line 1717 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 428: +#line 2016 "./parse.y" { yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 425: -#line 1719 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 429: +#line 2018 "./parse.y" { char *ptr; - while (ctxp->osb_number--) + while (CURRENT_OSB (ctxp)--) obstack_1grow (&temporary_obstack, '['); + ctxp->osb_depth--; obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (EXPR_WFL_NODE (yyvsp[-3].node)), IDENTIFIER_LENGTH (EXPR_WFL_NODE (yyvsp[-3].node))); @@ -4118,265 +4400,276 @@ case 425: yyval.node = build_cast (yyvsp[-4].operator.location, yyvsp[-3].node, yyvsp[0].node); ; break;} -case 426: -#line 1731 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 430: +#line 2031 "./parse.y" {yyerror ("']' expected, invalid type expression");; break;} -case 427: -#line 1733 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 431: +#line 2033 "./parse.y" { if (ctxp->prevent_ese != lineno) yyerror ("Invalid type expression"); RECOVER; RECOVER; ; break;} -case 428: -#line 1739 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 432: +#line 2039 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 429: -#line 1741 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 433: +#line 2041 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 430: -#line 1743 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 434: +#line 2043 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 432: -#line 1749 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 436: +#line 2049 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 433: -#line 1754 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 437: +#line 2054 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 434: -#line 1759 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 438: +#line 2059 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 435: -#line 1764 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 439: +#line 2064 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 436: -#line 1766 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 440: +#line 2066 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 437: -#line 1768 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 441: +#line 2068 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 439: -#line 1774 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 443: +#line 2074 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 440: -#line 1779 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 444: +#line 2079 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 441: -#line 1784 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 445: +#line 2084 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 442: -#line 1786 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 446: +#line 2086 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 444: -#line 1792 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 448: +#line 2092 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 445: -#line 1797 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 449: +#line 2097 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 446: -#line 1802 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 450: +#line 2102 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 447: -#line 1807 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 451: +#line 2107 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 448: -#line 1809 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 452: +#line 2109 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 449: -#line 1811 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 453: +#line 2111 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 451: -#line 1817 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 455: +#line 2117 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 452: -#line 1822 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 456: +#line 2122 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 453: -#line 1827 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 457: +#line 2127 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 454: -#line 1832 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 458: +#line 2132 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 456: -#line 1838 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 459: +#line 2137 "./parse.y" +{ yyval.node = build_binop (INSTANCEOF_EXPR, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; + break;} +case 460: +#line 2139 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 457: -#line 1840 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 461: +#line 2141 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 458: -#line 1842 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 462: +#line 2143 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 459: -#line 1844 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 463: +#line 2145 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 460: -#line 1846 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 464: +#line 2147 "./parse.y" {yyerror ("Invalid reference type"); RECOVER;; break;} -case 462: -#line 1852 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 466: +#line 2153 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 463: -#line 1857 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 467: +#line 2158 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 464: -#line 1862 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 468: +#line 2163 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 465: -#line 1864 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 469: +#line 2165 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 467: -#line 1870 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 471: +#line 2171 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 468: -#line 1875 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 472: +#line 2176 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 470: -#line 1881 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 474: +#line 2182 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 471: -#line 1886 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 475: +#line 2187 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 473: -#line 1892 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 477: +#line 2193 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 474: -#line 1897 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 478: +#line 2198 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 476: -#line 1903 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 480: +#line 2204 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 477: -#line 1908 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 481: +#line 2209 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 479: -#line 1914 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 483: +#line 2215 "./parse.y" { yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 480: -#line 1919 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 484: +#line 2220 "./parse.y" {yyerror ("Missing term"); RECOVER;; break;} -case 483: -#line 1926 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 486: +#line 2226 "./parse.y" +{ + yyval.node = build (CONDITIONAL_EXPR, NULL_TREE, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-3].operator.location; + ; + break;} +case 487: +#line 2231 "./parse.y" { YYERROR_NOW; yyerror ("Missing term"); DRECOVER (1); ; break;} -case 484: -#line 1932 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 488: +#line 2237 "./parse.y" {yyerror ("Missing term"); DRECOVER (2);; break;} -case 485: -#line 1934 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 489: +#line 2239 "./parse.y" {yyerror ("Missing term"); DRECOVER (3);; break;} -case 488: -#line 1944 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 492: +#line 2249 "./parse.y" { yyval.node = build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; break;} -case 489: -#line 1946 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +case 493: +#line 2251 "./parse.y" { if (ctxp->prevent_ese != lineno) yyerror ("Missing term"); @@ -4385,7 +4678,7 @@ case 489: break;} } /* the action file gets copied in in place of this dollarsign */ -#line 498 "/usr/cygnus/gnupro-98r1/share/bison.simple" +#line 498 "/usr/lib/bison.simple" yyvsp -= yylen; yyssp -= yylen; @@ -4581,12 +4874,10 @@ yyerrhandle: yystate = yyn; goto yynewstate; } -#line 1972 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y" +#line 2277 "./parse.y" -#include "lex.c" - /* Flag for the error report routine to issue the error the first time it's called (overriding the default behavior which is to drop the first invocation and honor the second one, taking advantage of a @@ -4599,18 +4890,32 @@ void java_push_parser_context () { struct parser_ctxt *new = - (struct parser_ctxt *)malloc(sizeof (struct parser_ctxt)); + (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt)); bzero (new, sizeof (struct parser_ctxt)); new->next = ctxp; ctxp = new; if (ctxp->next) - ctxp->incomplete_class = ctxp->next->incomplete_class; + { + ctxp->incomplete_class = ctxp->next->incomplete_class; + ctxp->gclass_list = ctxp->next->gclass_list; + } } +/* If the first file of a file list was a class file, no context + exists for a source file to be parsed. This boolean remembers that + java_parser_context_save_global might have created a dummy one, so + that java_parser_context_restore_global can pop it. */ +static int extra_ctxp_pushed_p = 0; + void java_parser_context_save_global () { + if (!ctxp) + { + java_push_parser_context (); + extra_ctxp_pushed_p = 1; + } ctxp->finput = finput; ctxp->lineno = lineno; ctxp->current_class = current_class; @@ -4626,18 +4931,29 @@ java_parser_context_restore_global () current_class = ctxp->current_class; input_filename = ctxp->filename; current_function_decl = ctxp->current_function_decl; + if (!ctxp->next && extra_ctxp_pushed_p) + { + java_pop_parser_context (0); + extra_ctxp_pushed_p = 0; + } } void -java_pop_parser_context () +java_pop_parser_context (generate) + int generate; { tree current; - struct parser_ctxt *toFree = ctxp; - struct parser_ctxt *next = ctxp->next; + struct parser_ctxt *toFree, *next; + + if (!ctxp) + return; + toFree = ctxp; + next = ctxp->next; if (next) { next->incomplete_class = ctxp->incomplete_class; + next->gclass_list = ctxp->gclass_list; lineno = ctxp->lineno; finput = ctxp->finput; current_class = ctxp->current_class; @@ -4649,11 +4965,28 @@ java_pop_parser_context () IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0; /* And restore those of the previous context */ - if (ctxp = next) + if ((ctxp = next)) /* Assignment is really meant here */ for (current = ctxp->import_list; current; current = TREE_CHAIN (current)) IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1; - free (toFree); + if (generate) + { + toFree->next = ctxp_for_generation; + ctxp_for_generation = toFree; + } + else + free (toFree); +} + +/* Reporting JDK1.1 features not implemented */ + +static tree +parse_jdk1_1_error (msg) + char *msg; +{ + sorry (": `%s' JDK1.1(TM) feature", msg); + java_error_count++; + return empty_stmt_node; } static int do_warning = 0; @@ -4666,7 +4999,7 @@ yyerror (msg) static int prev_lineno; static char *prev_msg; - int i, save_lineno; + int save_lineno; char *remainder, *code_from_source; extern struct obstack temporary_obstack; @@ -4725,68 +5058,151 @@ yyerror (msg) } static void -parse_error (msg) - char *msg; +issue_warning_error_from_context (cl, msg, ap) + tree cl; + const char *msg; + va_list ap; { + char *saved, *saved_input_filename; + char buffer [4096]; + vsprintf (buffer, msg, ap); + force_error = 1; + + ctxp->elc.line = EXPR_WFL_LINENO (cl); + ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : + (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl))); + + /* We have a CL, that's a good reason for using it if it contains data */ + saved = ctxp->filename; + if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl)) + ctxp->filename = EXPR_WFL_FILENAME (cl); + saved_input_filename = input_filename; + input_filename = ctxp->filename; java_error (NULL); - java_error (msg); + java_error (buffer); + ctxp->filename = saved; + input_filename = saved_input_filename; + force_error = 0; } /* Issue an error message at a current source line CL */ -static void -parse_error_context VPROTO ((tree cl, char *msg, ...)) +void +parse_error_context VPROTO ((tree cl, const char *msg, ...)) { -#ifndef __STDC__ +#ifndef ANSI_PROTOTYPES tree cl; - char *msg; + const char *msg; #endif - char buffer [4096]; va_list ap; VA_START (ap, msg); -#ifndef __STDC__ +#ifndef ANSI_PROTOTYPES cl = va_arg (ap, tree); - msg = va_arg (ap, char *); + msg = va_arg (ap, const char *); #endif - vsprintf (buffer, msg, ap); - - force_error = 1; - ctxp->elc.line = EXPR_WFL_LINENO (cl); - ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : EXPR_WFL_COLNO (cl)); - - parse_error (buffer); - force_error = 0; + issue_warning_error_from_context (cl, msg, ap); + va_end (ap); } /* Issue a warning at a current source line CL */ static void -parse_warning_context VPROTO ((tree cl, char *msg, ...)) +parse_warning_context VPROTO ((tree cl, const char *msg, ...)) { -#ifndef __STDC__ +#ifndef ANSI_PROTOTYPES tree cl; - char *msg; + const char *msg; #endif - char buffer [4096]; va_list ap; VA_START (ap, msg); -#ifndef __STDC__ +#ifndef ANSI_PROTOTYPES cl = va_arg (ap, tree); - msg = va_arg (ap, char *); + msg = va_arg (ap, const char *); #endif - vsprintf (buffer, msg, ap); force_error = do_warning = 1; - ctxp->elc.line = EXPR_WFL_LINENO (cl); - ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : EXPR_WFL_COLNO (cl)); - - parse_error (buffer); + issue_warning_error_from_context (cl, msg, ap); do_warning = force_error = 0; + va_end (ap); } -void +static tree +find_expr_with_wfl (node) + tree node; +{ + while (node) + { + char code; + tree to_return; + + switch (TREE_CODE (node)) + { + case BLOCK: + node = BLOCK_EXPR_BODY (node); + continue; + + case COMPOUND_EXPR: + to_return = find_expr_with_wfl (TREE_OPERAND (node, 0)); + if (to_return) + return to_return; + node = TREE_OPERAND (node, 1); + continue; + + case LOOP_EXPR: + node = TREE_OPERAND (node, 0); + continue; + + case LABELED_BLOCK_EXPR: + node = TREE_OPERAND (node, 1); + continue; + + default: + code = TREE_CODE_CLASS (TREE_CODE (node)); + if (((code == '1') || (code == '2') || (code == 'e')) + && EXPR_WFL_LINECOL (node)) + return node; + return NULL_TREE; + } + } + return NULL_TREE; +} + +/* Issue a missing return statement error. Uses METHOD to figure the + last line of the method the error occurs in. */ + +static void +missing_return_error (method) + tree method; +{ + EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2); + parse_error_context (wfl_operator, "Missing return statement"); +} + +/* Issue an unreachable statement error. From NODE, find the next + statement to report appropriately. */ +static void +unreachable_stmt_error (node) + tree node; +{ + /* Browse node to find the next expression node that has a WFL. Use + the location to report the error */ + if (TREE_CODE (node) == COMPOUND_EXPR) + node = find_expr_with_wfl (TREE_OPERAND (node, 1)); + else + node = find_expr_with_wfl (node); + + if (node) + { + EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2); + parse_error_context (wfl_operator, "Unreachable statement"); + } + else + fatal ("Can't get valid statement - unreachable_stmt_error"); +} + +int java_report_errors () { if (java_error_count) @@ -4797,6 +5213,7 @@ java_report_errors () java_warning_count, (java_warning_count == 1 ? "" : "s")); if (java_error_count || java_warning_count) putc ('\n', stderr); + return java_error_count; } static char * @@ -4825,8 +5242,11 @@ java_accstring_lookup (flags) #undef COPY_RETURN } +/* Issuing error messages upon redefinition of classes, interfaces or + variables. */ + static void -redefinition_error (context, id, decl, cl) +classitf_redefinition_error (context, id, decl, cl) char *context; tree id, decl, cl; { @@ -4836,6 +5256,74 @@ redefinition_error (context, id, decl, cl) /* Here we should point out where its redefined. It's a unicode. FIXME */ } +static void +variable_redefinition_error (context, name, type, line) + tree context, name, type; + int line; +{ + char *type_name; + + /* Figure a proper name for type. We might haven't resolved it */ + if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type)) + type_name = IDENTIFIER_POINTER (TYPE_NAME (type)); + else + type_name = lang_printable_name (type, 0); + + parse_error_context (context, + "Variable `%s' is already defined in this method and " + "was declared `%s %s' at line %d", + IDENTIFIER_POINTER (name), + type_name, IDENTIFIER_POINTER (name), line); +} + +static tree +build_array_from_name (type, type_wfl, name, ret_name) + tree type, type_wfl, name, *ret_name; +{ + int more_dims = 0; + char *string; + + /* Eventually get more dims */ + string = IDENTIFIER_POINTER (name); + while (string [more_dims] == '[') + more_dims++; + + /* If we have, then craft a new type for this variable */ + if (more_dims) + { + name = get_identifier (&string [more_dims]); + + /* If we have a pointer, use its type */ + if (TREE_CODE (type) == POINTER_TYPE) + type = TREE_TYPE (type); + + /* Building the first dimension of a primitive type uses this + function */ + if (JPRIMITIVE_TYPE_P (type)) + { + type = build_java_array_type (type, -1); + CLASS_LOADED_P (type) = 1; + more_dims--; + } + /* Otherwise, if we have a WFL for this type, use it (the type + is already an array on an unresolved type, and we just keep + on adding dimensions) */ + else if (type_wfl) + type = type_wfl; + + /* Add all the dimensions */ + while (more_dims--) + type = build_unresolved_array_type (type); + + /* The type may have been incomplete in the first place */ + if (type_wfl) + type = obtain_incomplete_type (type); + } + + *ret_name = name; + return type; +} + /* Build something that the type identifier resolver will identify as being an array to an unresolved type. TYPE_WFL is a WFL on a identifier. */ @@ -4846,7 +5334,7 @@ build_unresolved_array_type (type_or_wfl) { char *ptr; - /* TYPE_OR_WFL might be an array on a primitive type. In this case, + /* TYPE_OR_WFL might be an array on a resolved type. In this case, just create a array type */ if (TREE_CODE (type_or_wfl) == RECORD_TYPE) { @@ -4924,8 +5412,8 @@ check_class_interface_creation (is_interface, flags, raw_name, qualified_name, d } if (decl && CLASS_COMPLETE_P (decl)) { - redefinition_error ((is_interface ? "Interface" : "Class"), - qualified_name, decl, cl); + classitf_redefinition_error ((is_interface ? "Interface" : "Class"), + qualified_name, decl, cl); return 1; } @@ -4936,8 +5424,10 @@ check_class_interface_creation (is_interface, flags, raw_name, qualified_name, d /* Contains OS dependent assumption on path separator. FIXME */ for (f = &input_filename [strlen (input_filename)]; - f != input_filename && f[0] != '/'; f--); - if (f[0] == '/') + f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR; + f--) + ; + if (f[0] == '/' || f[0] == DIR_SEPARATOR) f++; if (strncmp (IDENTIFIER_POINTER (raw_name), f , IDENTIFIER_LENGTH (raw_name)) || @@ -4963,21 +5453,30 @@ static tree maybe_create_class_interface_decl (decl, qualified_name, cl) tree decl, qualified_name, cl; { - if (decl) - DECL_ARTIFICIAL (decl) = 1; /* FIXME */ - else + if (!decl) decl = push_class (make_class (), qualified_name); /* Take care of the file and line business */ DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl); - DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl); + /* If we're emiting xrefs, store the line/col number information */ + if (flag_emit_xref) + DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl); + else + DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl); CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1; + CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) = + IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl)); ctxp->current_parsed_class = decl; /* Link the declaration to the already seen ones */ TREE_CHAIN (decl) = ctxp->class_list; ctxp->class_list = decl; + + /* Create a new nodes in the global lists */ + ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list); + all_class_list = tree_cons (NULL_TREE, decl, all_class_list); + /* Install a new dependency list element */ create_jdep_list (ctxp); @@ -5000,11 +5499,12 @@ add_superinterfaces (decl, interface_list) defined. */ for (node = interface_list; node; node = TREE_CHAIN (node)) { - tree current = TREE_PURPOSE (node), interface_decl; - if ((interface_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current)))) + tree current = TREE_PURPOSE (node); + tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current)); + if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl))) { - if (!parser_check_super_interface (interface_decl, decl, current)) - parser_add_interface (decl, interface_decl, current); + if (!parser_check_super_interface (idecl, decl, current)) + parser_add_interface (decl, idecl, current); } else register_incomplete_type (JDEP_INTERFACE, @@ -5020,7 +5520,6 @@ create_interface (flags, id, super) int flags; tree id, super; { - int chk; tree raw_name = EXPR_WFL_NODE (id); tree q_name = parser_qualified_classname (id); tree decl = IDENTIFIER_CLASS_VALUE (q_name); @@ -5035,22 +5534,17 @@ create_interface (flags, id, super) - public/abstract allowed (already done at that point) - abstract is obsolete (comes first, it's a warning, or should be) - Can't use twice the same (checked in the modifier rule) */ - if (flags & ACC_ABSTRACT) + if ((flags & ACC_ABSTRACT) && flag_redundant) parse_warning_context (MODIFIER_WFL (ABSTRACT_TK), - "Obsolete use of `abstract' modifier. Interface `%s' is implicitely " + "Redundant use of `abstract' modifier. Interface `%s' is implicitely " "abstract", IDENTIFIER_POINTER (raw_name)); - if (flags & ACC_PUBLIC && flags & ACC_ABSTRACT) - parse_error_context - (MODIFIER_WFL (ABSTRACT_TK), - "Can't specify both `public' and `abstract' modifiers in the " - "definition of interface `%s'", IDENTIFIER_POINTER (raw_name)); /* Create a new decl if DECL is NULL, otherwise fix it */ decl = maybe_create_class_interface_decl (decl, q_name, id); /* Set super info and mark the class a complete */ - set_super_info (ACC_ABSTRACT | ACC_INTERFACE | flags, TREE_TYPE (decl), + set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl), object_type_node, ctxp->interface_number); ctxp->interface_number = 0; CLASS_COMPLETE_P (decl) = 1; @@ -5067,13 +5561,13 @@ create_class (flags, id, super, interfaces) int flags; tree id, super, interfaces; { - int chk; tree raw_name = EXPR_WFL_NODE (id); tree class_id, decl; - tree super_decl = NULL, super_decl_type; + tree super_decl_type; class_id = parser_qualified_classname (id); decl = IDENTIFIER_CLASS_VALUE (class_id); + ctxp->current_parsed_class_un = EXPR_WFL_NODE (id); EXPR_WFL_NODE (id) = class_id; /* Basic check: scope, redefinition, modifiers */ @@ -5101,17 +5595,8 @@ create_class (flags, id, super, interfaces) return NULL_TREE; } - /* The class is known and exists if there is a decl. Otherwise, - postpone the operation and do it later. */ - super_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (super)); - if (super_decl) - { - parser_check_super (super_decl, decl, id); - super_decl_type = TREE_TYPE (super_decl); - } - else - super_decl_type = - register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE); + super_decl_type = + register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE); } else if (TREE_TYPE (decl) != object_type_node) super_decl_type = object_type_node; @@ -5126,6 +5611,9 @@ create_class (flags, id, super, interfaces) CLASS_COMPLETE_P (decl) = 1; add_superinterfaces (decl, interfaces); + /* Eventually sets the @deprecated tag flag */ + CHECK_DEPRECATED (decl); + return decl; } @@ -5154,27 +5642,38 @@ lookup_field_wrapper (class, name) tree class, name; { tree type = class; - return lookup_field (&type, name); + tree decl; + java_parser_context_save_global (); + decl = lookup_field (&type, name); + java_parser_context_restore_global (); + return decl; } /* Find duplicate field within the same class declarations and report - the error */ + the error. Returns 1 if a duplicated field was found, 0 + otherwise. */ static int -duplicate_declaration_error (class, new_field_name, new_type, cl) - tree class, new_field_name, new_type, cl; +duplicate_declaration_error_p (new_field_name, new_type, cl) + tree new_field_name, new_type, cl; { /* This might be modified to work with method decl as well */ tree decl = find_field (TREE_TYPE (ctxp->current_parsed_class), new_field_name); if (decl) { - char *t1 = strdup ((char *)lang_printable_name (new_type, 1)); - char *t2 = - strdup ((TREE_CODE (TREE_TYPE (decl)) == TREE_LIST ? - IDENTIFIER_POINTER (TYPE_NAME - (TREE_PURPOSE (TREE_TYPE (decl)))) : - (char *)lang_printable_name (TREE_TYPE (decl), 1))); + char *t1 = strdup (purify_type_name + ((TREE_CODE (new_type) == POINTER_TYPE + && TREE_TYPE (new_type) == NULL_TREE) ? + IDENTIFIER_POINTER (TYPE_NAME (new_type)) : + lang_printable_name (new_type, 1))); + /* The type may not have been completed by the time we report + the error */ + char *t2 = strdup (purify_type_name + ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE + && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ? + IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) : + lang_printable_name (TREE_TYPE (decl), 1))); parse_error_context (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)", t1, IDENTIFIER_POINTER (new_field_name), @@ -5182,9 +5681,9 @@ duplicate_declaration_error (class, new_field_name, new_type, cl) DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl)); free (t1); free (t2); - return 0; + return 1; } - return 1; + return 0; } /* Field registration routine. If TYPE doesn't exist, field @@ -5196,7 +5695,7 @@ register_fields (flags, type, variable_list) int flags; tree type, variable_list; { - tree current, type_decl, returned_type; + tree current, saved_type; tree class_type = TREE_TYPE (ctxp->current_parsed_class); int saved_lineno = lineno; int must_chain = 0; @@ -5219,103 +5718,128 @@ register_fields (flags, type, variable_list) flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL); } - if (unresolved_type_p (type, &returned_type)) - { - if (returned_type) - type = returned_type; - else - { - wfl = type; - type = obtain_incomplete_type (type); - must_chain = 1; - } - } + /* Obtain a suitable type for resolution, if necessary */ + SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain); + + /* If TYPE is fully resolved and we don't have a reference, make one */ + PROMOTE_RECORD_IF_COMPLETE (type, must_chain); - for (current = variable_list; current; current = TREE_CHAIN (current)) + for (current = variable_list, saved_type = type; current; + current = TREE_CHAIN (current), type = saved_type) { + tree real_type; + tree field_decl; tree cl = TREE_PURPOSE (current); tree init = TREE_VALUE (current); tree current_name = EXPR_WFL_NODE (cl); - if (duplicate_declaration_error (class_type, current_name, type, cl)) - { - tree field_decl; - lineno = EXPR_WFL_LINENO (cl); - field_decl = add_field (class_type, current_name, type, flags); + /* Process NAME, as it may specify extra dimension(s) for it */ + type = build_array_from_name (type, wfl, current_name, ¤t_name); + + /* Type adjustment. We may have just readjusted TYPE because + the variable specified more dimensions. Make sure we have + a reference if we can and don't have one already. Also + change the name if we have an init. */ + if (type != saved_type) + { + PROMOTE_RECORD_IF_COMPLETE (type, must_chain); + if (init) + EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name; + } + + real_type = GET_REAL_TYPE (type); + /* Check for redeclarations */ + if (duplicate_declaration_error_p (current_name, real_type, cl)) + continue; - /* Check if we must chain. */ - if (must_chain) - register_incomplete_type (JDEP_FIELD, wfl, field_decl, type); + /* Set lineno to the line the field was found and create a + declaration for it. Eventually sets the @deprecated tag flag. */ + if (flag_emit_xref) + lineno = EXPR_WFL_LINECOL (cl); + else + lineno = EXPR_WFL_LINENO (cl); + field_decl = add_field (class_type, current_name, real_type, flags); + CHECK_DEPRECATED (field_decl); + + /* Check if we must chain. */ + if (must_chain) + register_incomplete_type (JDEP_FIELD, wfl, field_decl, type); - /* Default value of a static field is 0 and it is considered - initialized. */ + /* If we have an initialization value tied to the field */ + if (init) + { + /* The field is declared static */ if (flags & ACC_STATIC) - INITIALIZED_P (field_decl) = 1; - - /* If we have an initialization value tied to the field */ - if (init) { - /* The field is declared static */ - if (flags & ACC_STATIC) - { - /* FIXME */ - if (flags & ACC_FINAL) - ; - /* Otherwise, the field should be initialized in - <clinit>. This field is remembered so we can - generate <clinit> later. */ - else - { - INITIALIZED_P (field_decl) = 1; - TREE_CHAIN (init) = ctxp->static_initialized; - ctxp->static_initialized = init; - } - } - /* A non-static field declared with an immediate - initialization is to be initialized in <init>, if - any. This field is remembered to be processed at the - time of the generation of <init>. */ - else - { - TREE_CHAIN (init) = ctxp->non_static_initialized; - ctxp->non_static_initialized = init; - } + /* We include the field and its initialization part into + a list used to generate <clinit>. After <clinit> is + walked, field initializations will be processed and + fields initialized with known constants will be taken + out of <clinit> and have their DECL_INITIAL set + appropriately. */ + TREE_CHAIN (init) = ctxp->static_initialized; + ctxp->static_initialized = init; + DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1); + if (TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT) + TREE_STATIC (TREE_OPERAND (init, 1)) = 1; } + /* A non-static field declared with an immediate initialization is + to be initialized in <init>, if any. This field is remembered + to be processed at the time of the generation of <init>. */ + else + { + TREE_CHAIN (init) = ctxp->non_static_initialized; + ctxp->non_static_initialized = init; + } + MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1; } } lineno = saved_lineno; } +/* Generate the method $finit$ that initializes fields initialized + upon declaration. */ + +static void +maybe_generate_finit () +{ + tree mdecl, current; + + if (!ctxp->non_static_initialized || java_error_count) + return; + + mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class), + ACC_PRIVATE, void_type_node, + finit_identifier_node, end_params_node); + start_artificial_method_body (mdecl); + + ctxp->non_static_initialized = nreverse (ctxp->non_static_initialized); + for (current = ctxp->non_static_initialized; current; + current = TREE_CHAIN (current)) + java_method_add_stmt (mdecl, + build_debugable_stmt (EXPR_WFL_LINECOL (current), + current)); + + end_artificial_method_body (mdecl); + CLASS_HAS_FINIT_P (TREE_TYPE (ctxp->current_parsed_class)) = 1; + ctxp->non_static_initialized = NULL_TREE; +} + /* Check whether it is necessary to generate a <clinit> for the class we just parsed. */ static void maybe_generate_clinit () { - int saved_lineno; - tree meth, mdecl, c; - tree cclass, class_wfl; + tree mdecl, c; if (!ctxp->static_initialized || java_error_count) return; - cclass = TREE_TYPE (ctxp->current_parsed_class); - class_wfl = build_expr_wfl (DECL_NAME (TYPE_NAME (cclass)), - input_filename, 0, 0); - - saved_lineno = lineno; - lineno = 0; - meth = make_node (FUNCTION_TYPE); - TREE_TYPE (meth) = void_type_node; - TYPE_ARG_TYPES (meth) = NULL_TREE; - mdecl = add_method (cclass, ACC_STATIC, clinit_identifier_node, - build_java_signature (meth)); - lineno = saved_lineno; - - DECL_SOURCE_LINE (mdecl) = 1; - DECL_SOURCE_LINE_MERGE (mdecl, 1); - source_start_java_method (mdecl); - enter_block (); + mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class), + ACC_STATIC, void_type_node, + clinit_identifier_node, end_params_node); + start_artificial_method_body (mdecl); /* Keep initialization in order to enforce 8.5 */ ctxp->static_initialized = nreverse (ctxp->static_initialized); @@ -5328,11 +5852,11 @@ maybe_generate_clinit () /* We build the assignment expression that will initialize the field to its value. There are strict rules on static initializers (8.5). FIXME */ - java_method_add_stmt (mdecl, c); + java_method_add_stmt (mdecl, + build_debugable_stmt (EXPR_WFL_LINECOL (c), c)); } - BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block (); - exit_block (); + end_artificial_method_body (mdecl); ctxp->static_initialized = NULL_TREE; } @@ -5347,7 +5871,8 @@ static int patch_stage; /* Check the method declaration and add the method to its current class. If the argument list is known to contain incomplete types, the method is partially added and the registration will be resume - once the method arguments resolved */ + once the method arguments resolved. If TYPE is NULL, we're dealing + with a constructor. */ static tree method_header (flags, type, mdecl, throws) @@ -5357,33 +5882,58 @@ method_header (flags, type, mdecl, throws) tree meth = TREE_VALUE (mdecl); tree id = TREE_PURPOSE (mdecl); tree this_class = TREE_TYPE (ctxp->current_parsed_class); - tree handle_class = CLASS_TO_HANDLE_TYPE (this_class); - tree meth_name, returned_type; + tree type_wfl = NULL_TREE; + tree meth_name = NULL_TREE, current, orig_arg; int saved_lineno; + int constructor_ok = 0, must_chain; check_modifiers_consistency (flags); /* There are some forbidden modifiers for an abstract method and its class must be abstract as well. */ - if (flags & ACC_ABSTRACT) + if (type && (flags & ACC_ABSTRACT)) { ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private"); ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static"); ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final"); ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native"); ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized"); - if (!CLASS_ABSTRACT (TYPE_NAME (this_class))) + if (!CLASS_ABSTRACT (TYPE_NAME (this_class)) + && !CLASS_INTERFACE (TYPE_NAME (this_class))) parse_error_context (id, "Class `%s' must be declared abstract to define abstract " "method `%s'", IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)), IDENTIFIER_POINTER (EXPR_WFL_NODE (id))); } - + /* Things to be checked when declaring a constructor */ + if (!type) + { + int ec = java_error_count; + /* 8.6: Constructor declarations: we might be trying to define a + method without specifying a return type. */ + if (EXPR_WFL_NODE (id) != ctxp->current_parsed_class_un) + parse_error_context + (id, "Invalid method declaration, return type required"); + /* 8.6.3: Constructor modifiers */ + else + { + JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract"); + JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static"); + JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final"); + JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native"); + JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized"); + } + /* If we found error here, we don't consider it's OK to tread + the method definition as a constructor, for the rest of this + function */ + if (ec == java_error_count) + constructor_ok = 1; + } /* Method declared within the scope of an interface are implicitly abstract and public. Conflicts with other erroneously provided - modifiers are check right after. */ + modifiers are checked right after. */ if (CLASS_INTERFACE (TYPE_NAME (this_class))) { @@ -5401,18 +5951,31 @@ method_header (flags, type, mdecl, throws) /* Modifiers context reset moved up, so abstract method declaration modifiers can be later checked. */ - meth_name = EXPR_WFL_NODE (id); + /* Set constructor returned type to void and method name to <init>, + unless we found an error identifier the constructor (in which + case we retain the original name) */ + if (!type) + { + type = void_type_node; + if (constructor_ok) + meth_name = init_identifier_node; + } + else + meth_name = EXPR_WFL_NODE (id); + + /* Do the returned type resolution and registration if necessary */ + SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain); - if (unresolved_type_p (type, &returned_type)) + if (meth_name) + type = build_array_from_name (type, type_wfl, meth_name, &meth_name); + EXPR_WFL_NODE (id) = meth_name; + PROMOTE_RECORD_IF_COMPLETE (type, must_chain); + + if (must_chain) { - if (returned_type) - TREE_TYPE (meth) = returned_type; - else - { - patch_stage = JDEP_METHOD_RETURN; - TREE_TYPE (meth) = - register_incomplete_type (patch_stage, type, id, NULL_TREE); - } + patch_stage = JDEP_METHOD_RETURN; + register_incomplete_type (patch_stage, type_wfl, id, type); + TREE_TYPE (meth) = GET_REAL_TYPE (type); } else TREE_TYPE (meth) = type; @@ -5424,6 +5987,9 @@ method_header (flags, type, mdecl, throws) lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 : EXPR_WFL_LINENO (id)); + /* Remember the original argument list */ + orig_arg = TYPE_ARG_TYPES (meth); + if (patch_stage) /* includes ret type and/or all args */ { jdep *jdep; @@ -5439,41 +6005,150 @@ method_header (flags, type, mdecl, throws) register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE); } else + meth = add_method (this_class, flags, meth_name, + build_java_signature (meth)); + + /* Fix the method argument list so we have the argument name + information */ + fix_method_argument_names (orig_arg, meth); + + /* Register the parameter number and re-install the current line + number */ + DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1; + lineno = saved_lineno; + + /* Register exception specified by the `throws' keyword for + resolution and set the method decl appropriate field to the list. + Note: the grammar ensures that what we get here are class + types. */ + if (throws) { - tree signature = build_java_signature (meth); - tree arg, orig_arg; - /* Save original argument list, including argument's names */ - orig_arg = TYPE_ARG_TYPES (meth); - /* Add the method to its class */ - meth = add_method (this_class, flags, meth_name, signature); - /* Fix the method argument list so we have the argument name - information */ - arg = TYPE_ARG_TYPES (TREE_TYPE (meth)); - if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE) - { - TREE_PURPOSE (arg) = this_identifier_node; - arg = TREE_CHAIN (arg); - } - while (orig_arg) - { - TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg); - orig_arg = TREE_CHAIN (orig_arg); - arg = TREE_CHAIN (arg); + throws = nreverse (throws); + for (current = throws; current; current = TREE_CHAIN (current)) + { + register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current), + NULL_TREE, NULL_TREE); + JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) = + &TREE_VALUE (current); } + DECL_FUNCTION_THROWS (meth) = throws; } - DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1; - lineno = saved_lineno; + /* We set the DECL_NAME to ID so we can track the location where the function was declared. This allow us to report redefinition error accurately. When method are verified, DECL_NAME is reinstalled properly (using the content of the WFL node ID) (see check_method_redefinition). We don't do that - when Object is being defined. */ + when Object is being defined. Constructor <init> names will be + reinstalled the same way. */ if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node) DECL_NAME (meth) = id; + + /* Set the flag if we correctly processed a constructor */ + if (constructor_ok) + DECL_CONSTRUCTOR_P (meth) = 1; + + /* Eventually set the @deprecated tag flag */ + CHECK_DEPRECATED (meth); + return meth; } +static void +fix_method_argument_names (orig_arg, meth) + tree orig_arg, meth; +{ + tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth)); + if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE) + { + TREE_PURPOSE (arg) = this_identifier_node; + arg = TREE_CHAIN (arg); + } + while (orig_arg != end_params_node) + { + TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg); + orig_arg = TREE_CHAIN (orig_arg); + arg = TREE_CHAIN (arg); + } +} + +/* Complete the method declaration with METHOD_BODY. */ + +static void +finish_method_declaration (method_body) + tree method_body; +{ + BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body; + maybe_absorb_scoping_blocks (); + /* Exit function's body */ + exit_block (); + /* Merge last line of the function with first line, directly in the + function decl. It will be used to emit correct debug info. */ + DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1); + /* So we don't have an irrelevant function declaration context for + the next static block we'll see. */ + current_function_decl = NULL_TREE; +} + +/* Build a an error message for constructor circularity errors. */ + +static char * +constructor_circularity_msg (from, to) + tree from, to; +{ + static char string [4096]; + char *t = strdup (lang_printable_name (from, 0)); + sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0)); + free (t); + return string; +} + +/* Verify a circular call to METH. Return 1 if an error is found, 0 + otherwise. */ + +static int +verify_constructor_circularity (meth, current) + tree meth, current; +{ + static tree list = NULL_TREE; + tree c; + for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c)) + { + if (TREE_VALUE (c) == meth) + { + char *t; + if (list) + { + tree liste; + list = nreverse (list); + for (liste = list; liste; liste = TREE_CHAIN (liste)) + { + parse_error_context + (TREE_PURPOSE (TREE_PURPOSE (liste)), + constructor_circularity_msg + (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste)))); + java_error_count--; + } + } + t = strdup (lang_printable_name (meth, 0)); + parse_error_context (TREE_PURPOSE (c), + "%s: recursive invocation of constructor `%s'", + constructor_circularity_msg (current, meth), t); + free (t); + list = NULL_TREE; + return 1; + } + } + for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c)) + { + list = tree_cons (c, current, list); + if (verify_constructor_circularity (meth, TREE_VALUE (c))) + return 1; + list = TREE_CHAIN (list); + } + return 0; +} + /* Check modifiers that can be declared but exclusively */ static void @@ -5500,8 +6175,7 @@ check_abstract_method_header (meth) { int flags = get_access_flags_from_decl (meth); /* DECL_NAME might still be a WFL node */ - tree name = (TREE_CODE (DECL_NAME (meth)) == EXPR_WITH_FILE_LOCATION ? - EXPR_WFL_NODE (DECL_NAME (meth)) : DECL_NAME (meth)); + tree name = GET_METHOD_NAME (meth); OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (ABSTRACT_TK), flags, ACC_ABSTRACT, "abstract method `%s'", @@ -5526,17 +6200,33 @@ method_declarator (id, list) tree arg_types = NULL_TREE, current, node; tree meth = make_node (FUNCTION_TYPE); jdep *jdep; - int incomplete = 0; patch_stage = JDEP_NO_PATCH; for (current = list; current; current = TREE_CHAIN (current)) { + int must_chain = 0; tree wfl_name = TREE_PURPOSE (current); tree type = TREE_VALUE (current); tree name = EXPR_WFL_NODE (wfl_name); - tree patchable_type = NULL_TREE, already; - tree arg_node, returned_type; + tree already, arg_node; + tree type_wfl = NULL_TREE; + tree real_type; + + /* Obtain a suitable type for resolution, if necessary */ + SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain); + + /* Process NAME, as it may specify extra dimension(s) for it */ + type = build_array_from_name (type, type_wfl, name, &name); + EXPR_WFL_NODE (wfl_name) = name; + + real_type = GET_REAL_TYPE (type); + if (TREE_CODE (real_type) == RECORD_TYPE) + { + real_type = promote_type (real_type); + if (TREE_CODE (type) == TREE_LIST) + TREE_PURPOSE (type) = real_type; + } /* Check redefinition */ for (already = arg_types; already; already = TREE_CHAIN (already)) @@ -5552,27 +6242,23 @@ method_declarator (id, list) /* If we've an incomplete argument type, we know there is a location to patch when the type get resolved, later. */ jdep = NULL; - if (unresolved_type_p (type, &returned_type)) + if (must_chain) { - if (returned_type) - type = returned_type; - else - { - patch_stage = JDEP_METHOD; - type = register_incomplete_type (patch_stage, type, - wfl_name, NULL_TREE); - jdep = CLASSD_LAST (ctxp->classd_list); - JDEP_MISC (jdep) = id; - } + patch_stage = JDEP_METHOD; + type = register_incomplete_type (patch_stage, + type_wfl, wfl_name, type); + jdep = CLASSD_LAST (ctxp->classd_list); + JDEP_MISC (jdep) = id; } + /* The argument node: a name and a (possibly) incomplete type */ - arg_node = build_tree_list (name, type); + arg_node = build_tree_list (name, real_type); if (jdep) JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node); TREE_CHAIN (arg_node) = arg_types; arg_types = arg_node; } - TYPE_ARG_TYPES (meth) = nreverse (arg_types); + TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node); node = build_tree_list (id, meth); return node; } @@ -5647,7 +6333,6 @@ static int parser_check_super (super_decl, this_decl, wfl) tree super_decl, this_decl, wfl; { - tree this_type = TREE_TYPE (this_decl); tree super_type = TREE_TYPE (super_decl); /* SUPER should be a CLASS (neither an array nor an interface) */ @@ -5685,11 +6370,7 @@ static void create_jdep_list (ctxp) struct parser_ctxt *ctxp; { - jdeplist *new = malloc (sizeof (jdeplist)); - - if (!new) - fatal ("Can't alloc jdeplist - create_jdep_list"); - + jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist)); new->first = new->last = NULL; new->next = ctxp->classd_list; ctxp->classd_list = new; @@ -5709,25 +6390,32 @@ reverse_jdep_list (ctxp) return prev; } -/* Create a fake pointer based on the ID stored in the WFL */ +/* Create a fake pointer based on the ID stored in + TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be + registered again. */ static tree -obtain_incomplete_type (wfl) - tree wfl; +obtain_incomplete_type (type_name) + tree type_name; { - tree ptr; - tree name = EXPR_WFL_NODE (wfl); + tree ptr, name; + + if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION) + name = EXPR_WFL_NODE (type_name); + else if (INCOMPLETE_TYPE_P (type_name)) + name = TYPE_NAME (type_name); + else + fatal ("invalid type name - obtain_incomplete_type"); for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr)) - if (TYPE_NAME (TREE_PURPOSE (ptr)) == name) + if (TYPE_NAME (ptr) == name) break; if (!ptr) { - tree core; push_obstacks (&permanent_obstack, &permanent_obstack); - BUILD_PTR_FROM_NAME (core, name); - ptr = build_tree_list (core, NULL_TREE); + BUILD_PTR_FROM_NAME (ptr, name); + layout_type (ptr); pop_obstacks (); TREE_CHAIN (ptr) = ctxp->incomplete_class; ctxp->incomplete_class = ptr; @@ -5746,10 +6434,8 @@ register_incomplete_type (kind, wfl, decl, ptr) int kind; tree wfl, decl, ptr; { - jdep *new = malloc (sizeof (jdep)); + jdep *new = (jdep *)xmalloc (sizeof (jdep)); - if (!new) - fatal ("Can't allocate new jdep - register_incomplete_type"); if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */ ptr = obtain_incomplete_type (wfl); @@ -5798,6 +6484,10 @@ java_check_circular_reference () } } +/* safe_layout_class just makes sure that we can load a class without + disrupting the current_class, input_file, lineno, etc, information + about the class processed currently. */ + void safe_layout_class (class) tree class; @@ -5805,11 +6495,12 @@ safe_layout_class (class) tree save_current_class = current_class; char *save_input_filename = input_filename; int save_lineno = lineno; - + push_obstacks (&permanent_obstack, &permanent_obstack); + layout_class (class); pop_obstacks (); - + current_class = save_current_class; input_filename = save_input_filename; lineno = save_lineno; @@ -5822,20 +6513,18 @@ jdep_resolve_class (dep) { tree decl; - if (!JDEP_RESOLVED_P (dep)) + if (JDEP_RESOLVED_P (dep)) + decl = JDEP_RESOLVED_DECL (dep); + else { - decl = - resolve_class (JDEP_TO_RESOLVE (dep), JDEP_DECL (dep), JDEP_WFL (dep)); + decl = resolve_class (JDEP_TO_RESOLVE (dep), + JDEP_DECL (dep), JDEP_WFL (dep)); JDEP_RESOLVED (dep, decl); } - else - decl = JDEP_RESOLVED_DECL (dep); - + if (!decl) - { - complete_class_report_errors (dep); - return NULL_TREE; - } + complete_class_report_errors (dep); + return decl; } @@ -5844,10 +6533,10 @@ jdep_resolve_class (dep) void java_complete_class () { - tree current; tree cclass; jdeplist *cclassd; int error_found; + tree type; push_obstacks (&permanent_obstack, &permanent_obstack); @@ -5859,7 +6548,7 @@ java_complete_class () /* Rever things so we have the right order */ ctxp->class_list = nreverse (ctxp->class_list); ctxp->classd_list = reverse_jdep_list (ctxp); - + for (cclassd = ctxp->classd_list, cclass = ctxp->class_list; cclass && cclassd; cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd)) @@ -5868,7 +6557,6 @@ java_complete_class () for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep)) { tree decl; - if (!(decl = jdep_resolve_class (dep))) continue; @@ -5889,12 +6577,12 @@ java_complete_class () tree field_decl = JDEP_DECL (dep); tree field_type = TREE_TYPE (decl); push_obstacks (&permanent_obstack, &permanent_obstack); -#if ! JAVA_PROMOTE_TO_INT if (TREE_CODE (field_type) == RECORD_TYPE) -#endif field_type = promote_type (field_type); pop_obstacks (); TREE_TYPE (field_decl) = field_type; + DECL_ALIGN (field_decl) = 0; + layout_decl (field_decl, 0); SOURCE_FRONTEND_DEBUG (("Completed field/var decl `%s' with `%s'", IDENTIFIER_POINTER (DECL_NAME (field_decl)), @@ -5908,7 +6596,9 @@ java_complete_class () { if (decl) { - tree type = promote_type (TREE_TYPE(decl)); + type = TREE_TYPE(decl); + if (TREE_CODE (type) == RECORD_TYPE) + type = promote_type (type); JDEP_APPLY_PATCH (dep, type); SOURCE_FRONTEND_DEBUG (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ? @@ -5946,14 +6636,12 @@ java_complete_class () parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep)); break; + case JDEP_PARM: case JDEP_VARIABLE: - JDEP_APPLY_PATCH (dep, promote_type (TREE_TYPE (decl))); - SOURCE_FRONTEND_DEBUG - (("Completing variable `%s' with type `%s'", - (TREE_CODE (JDEP_DECL_WFL (dep)) == EXPR_WITH_FILE_LOCATION ? - IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))) : - IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL_WFL (dep)))), - IDENTIFIER_POINTER (DECL_NAME (decl)))); + type = TREE_TYPE(decl); + if (TREE_CODE (type) == RECORD_TYPE) + type = promote_type (type); + JDEP_APPLY_PATCH (dep, type); break; case JDEP_TYPE: @@ -5963,16 +6651,16 @@ java_complete_class () tree_code_name [TREE_CODE (JDEP_DECL (dep))])); break; - case JDEP_PARM: - JDEP_APPLY_PATCH (dep, promote_type (TREE_TYPE (decl))); + case JDEP_EXCEPTION: + JDEP_APPLY_PATCH (dep, TREE_TYPE (decl)); SOURCE_FRONTEND_DEBUG - (("Completing parameter `%s' with type `%s'", - IDENTIFIER_POINTER (JDEP_MISC (dep)), - IDENTIFIER_POINTER (DECL_NAME (decl)))); + (("Completing `%s' `throws' argument node", + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))))); break; default: - fatal ("incomplete switch - java_complete_class"); + fatal ("Can't handle patch code %d - java_complete_class", + JDEP_KIND (dep)); } } } @@ -5989,8 +6677,22 @@ resolve_class (class_type, decl, cl) { char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type)); char *base = name; - tree resolved_type, resolved_type_decl; + tree resolved_type = TREE_TYPE (class_type); + tree resolved_type_decl; + if (resolved_type != NULL_TREE) + { + tree resolved_type_decl = TYPE_NAME (resolved_type); + if (resolved_type_decl == NULL_TREE + || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE) + { + resolved_type_decl = build_decl (TYPE_DECL, + TYPE_NAME (class_type), + resolved_type); + } + return resolved_type_decl; + } + /* 1- Check to see if we have an array. If true, find what we really want to resolve */ while (name[0] == '[') @@ -6011,6 +6713,7 @@ resolve_class (class_type, decl, cl) if (TREE_CODE (resolved_type) == RECORD_TYPE) resolved_type = promote_type (resolved_type); resolved_type = build_java_array_type (resolved_type, -1); + CLASS_LOADED_P (resolved_type) = 1; name--; } /* Build a fake decl for this, since this is what is expected to @@ -6020,14 +6723,16 @@ resolve_class (class_type, decl, cl) /* Figure how those two things are important for error report. FIXME */ DECL_SOURCE_LINE (resolved_type_decl) = 0; DECL_SOURCE_FILE (resolved_type_decl) = input_filename; + TYPE_NAME (class_type) = TYPE_NAME (resolved_type); } + TREE_TYPE (class_type) = resolved_type; return resolved_type_decl; } /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL are used to report error messages. */ -static tree +tree do_resolve_class (class_type, decl, cl) tree class_type; tree decl; @@ -6045,7 +6750,6 @@ do_resolve_class (class_type, decl, cl) /* 2- And check for the type in the current compilation unit. If it fails, try with a name qualified with the package name if appropriate. */ - if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)))) { if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) && @@ -6058,6 +6762,9 @@ do_resolve_class (class_type, decl, cl) if (!QUALIFIED_P (TYPE_NAME (class_type)) && ctxp->package) TYPE_NAME (class_type) = merge_qualified_name (ctxp->package, TYPE_NAME (class_type)); +#if 1 + if (!(new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)))) + load_class (TYPE_NAME (class_type), 0); if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)))) { if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) && @@ -6065,6 +6772,27 @@ do_resolve_class (class_type, decl, cl) load_class (TYPE_NAME (class_type), 0); return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)); } +#else + new_name = TYPE_NAME (class_type); + if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_name)) != NULL_TREE) + { + if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) && + !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl))) + load_class (new_name, 0); + return IDENTIFIER_CLASS_VALUE (new_name); + } + else + { + tree class = read_class (new_name); + if (class != NULL_TREE) + { + tree decl = IDENTIFIER_CLASS_VALUE (new_name); + if (decl == NULL_TREE) + decl = push_class (class, new_name); + return decl; + } + } +#endif TYPE_NAME (class_type) = original_name; /* 3- Check an other compilation unit that bears the name of type */ @@ -6087,17 +6815,59 @@ do_resolve_class (class_type, decl, cl) } /* Resolve NAME and lay it out (if not done and if not the current - parsed class). Return a decl node. */ + parsed class). Return a decl node. This function is meant to be + called when type resolution is necessary during the walk pass. */ static tree -resolve_and_layout (name, cl) - tree name; +resolve_and_layout (something, cl) + tree something; tree cl; { - tree decl = resolve_no_layout (name, cl); - if (decl && TREE_TYPE (decl) != current_class - && !CLASS_LOADED_P (TREE_TYPE (decl))) + tree decl; + + /* Don't do that on the current class */ + if (something == current_class) + return TYPE_NAME (current_class); + + /* Don't do anything for void and other primitive types */ + if (JPRIMITIVE_TYPE_P (something) || something == void_type_node) + return NULL_TREE; + + /* Pointer types can be reall pointer types or fake pointers. When + finding a real pointer, recheck for primitive types */ + if (TREE_CODE (something) == POINTER_TYPE) + { + if (TREE_TYPE (something)) + { + something = TREE_TYPE (something); + if (JPRIMITIVE_TYPE_P (something) || something == void_type_node) + return NULL_TREE; + } + else + something = TYPE_NAME (something); + } + + /* Don't do anything for arrays of primitive types */ + if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something) + && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something))) + return NULL_TREE; + + /* If something is not and IDENTIFIER_NODE, it can be a a TYPE_DECL + or a real TYPE */ + if (TREE_CODE (something) != IDENTIFIER_NODE) + something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ? + DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something)); + + if (!(decl = resolve_no_layout (something, cl))) + return NULL_TREE; + + /* Resolve and layout if necessary */ + layout_class_methods (TREE_TYPE (decl)); + if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl))) + CHECK_METHODS (decl); + if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl))) safe_layout_class (TREE_TYPE (decl)); + return decl; } @@ -6117,8 +6887,8 @@ resolve_no_layout (name, cl) return decl; } -/* Called to report errors. Skip leader '[' in a complex array type - description that failed to be resolved. */ +/* Called when reporting errors. Skip leader '[' in a complex array + type description that failed to be resolved. */ static char * purify_type_name (name) @@ -6135,25 +6905,31 @@ static void complete_class_report_errors (dep) jdep *dep; { + char *name; + + if (!JDEP_WFL (dep)) + return; + + name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))); switch (JDEP_KIND (dep)) { case JDEP_SUPER: parse_error_context (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found", - IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))), + purify_type_name (name), IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep)))); break; case JDEP_FIELD: parse_error_context (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))), + purify_type_name (name), IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep)))); break; case JDEP_METHOD: /* Covers arguments */ parse_error_context (JDEP_WFL (dep), "Type `%s' not found in the declaration of the " "argument `%s' of method `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))), + purify_type_name (name), IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))), IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep)))); break; @@ -6161,7 +6937,7 @@ complete_class_report_errors (dep) parse_error_context (JDEP_WFL (dep), "Type `%s' not found in the declaration of the " "return type of method `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))), + purify_type_name (name), IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep)))); break; case JDEP_INTERFACE: @@ -6175,9 +6951,19 @@ complete_class_report_errors (dep) parse_error_context (JDEP_WFL (dep), "Type `%s' not found in the declaration of the " "local variable `%s'", - purify_type_name (IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))), + purify_type_name (IDENTIFIER_POINTER + (EXPR_WFL_NODE (JDEP_WFL (dep)))), IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep)))); break; + case JDEP_EXCEPTION: /* As specified by `throws' */ + parse_error_context + (JDEP_WFL (dep), "Class `%s' not found in `throws'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))); + break; + default: + /* Fix for -Wall. Just break doing nothing. The error will be + caught later */ + break; } } @@ -6188,35 +6974,107 @@ java_check_final () { } +/* Return a static string containing the DECL prototype string. If + DECL is a constructor, use the class name instead of the form + <init> */ + +static char * +get_printable_method_name (decl) + tree decl; +{ + char *to_return; + tree name = NULL_TREE; + + if (DECL_CONSTRUCTOR_P (decl)) + { + name = DECL_NAME (decl); + DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))); + } + + to_return = lang_printable_name (decl, 0); + if (DECL_CONSTRUCTOR_P (decl)) + DECL_NAME (decl) = name; + + return to_return; +} + +/* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method + nevertheless needs to be verfied, 1 otherwise. */ + static int -check_method_redefinition (class, method) - tree class, method; +reset_method_name (method) + tree method; { - tree redef, name; - tree cl = DECL_NAME (method); - tree sig = TYPE_LANG_SPECIFIC (TREE_TYPE (method))->signature; - /* decl name of generated <clinit> doesn't need to be fixed and - checked */ - if (DECL_NAME (method) != clinit_identifier_node) + if (DECL_NAME (method) != clinit_identifier_node + && DECL_NAME (method) != finit_identifier_node) { /* NAME is just the plain name when Object is being defined */ - if (class != object_type_node) - name = DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method)); - else - name = DECL_NAME (method); + if (DECL_CONTEXT (method) != object_type_node) + DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ? + init_identifier_node : GET_METHOD_NAME (method)); + return 0; } else + return 1; +} + +/* Return the name of METHOD_DECL, when DECL_NAME is a WFL */ + +tree +java_get_real_method_name (method_decl) + tree method_decl; +{ + tree method_name = DECL_NAME (method_decl); + if (DECL_CONSTRUCTOR_P (method_decl)) + return init_identifier_node; + + /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P + and still can be a constructor. FIXME */ + + /* Don't confuse method only bearing the name of their class as + constructors */ + else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl)) + && ctxp + && ctxp->current_parsed_class_un == EXPR_WFL_NODE (method_name) + && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED + && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node) + return init_identifier_node; + else + return EXPR_WFL_NODE (method_name); +} + +/* Track method being redefined inside the same class. As a side + effect, set DECL_NAME to an IDENTIFIER (prior entering this + function it's a FWL, so we can track errors more accurately */ + +static int +check_method_redefinition (class, method) + tree class, method; +{ + tree redef, name; + tree cl = DECL_NAME (method); + tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method)); + /* decl name of artificial <clinit> and $finit$ doesn't need to be + fixed and checked */ + + /* Reset the method name before running the check. If it returns 1, + the method doesn't need to be verified with respect to method + redeclaration and we return 0 */ + if (reset_method_name (method)) return 0; - + + name = DECL_NAME (method); for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef)) { - struct lang_type *t = TYPE_LANG_SPECIFIC (TREE_TYPE (redef)); - - if (! t || (redef == method)) + if (redef == method) break; - if (DECL_NAME (redef) == name && sig == t->signature) + if (DECL_NAME (redef) == name + && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))) { - parse_error_context (cl, "Duplicate method declaration"); + parse_error_context + (cl, "Duplicate %s declaration `%s'", + (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"), + get_printable_method_name (redef)); return 1; } } @@ -6231,40 +7089,92 @@ static void java_check_regular_methods (class_decl) tree class_decl; { + int saw_constructor = 0; tree method; tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl)); tree super_class = CLASSTYPE_SUPER (class); - int seen_constructor = 0; + tree saved_found_wfl = NULL_TREE, found = NULL_TREE; + tree mthrows; + + /* It is not necessary to check methods defined in java.lang.Object */ + if (class == object_type_node) + return; - TYPE_METHODS (class) = nreverse (TYPE_METHODS (class)); + if (!TYPE_NVIRTUALS (class)) + TYPE_METHODS (class) = nreverse (TYPE_METHODS (class)); /* Should take interfaces into account. FIXME */ for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method)) { - tree found, sig; + tree sig; tree method_wfl = DECL_NAME (method); int aflags; - if (DECL_CONSTRUCTOR_P (method)) - seen_constructor = 1; + /* If we previously found something and its name was saved, + reinstall it now */ + if (found && saved_found_wfl) + { + DECL_NAME (found) = saved_found_wfl; + saved_found_wfl = NULL_TREE; + } /* Check for redefinitions */ if (check_method_redefinition (class, method)) continue; - sig = build_java_argument_signature (TREE_TYPE (method)); + /* If we see one constructor a mark so we don't generate the + default one. Also skip other verifications: constructors + can't be inherited hence hiden or overriden */ + if (DECL_CONSTRUCTOR_P (method)) + { + saw_constructor = 1; + continue; + } + + /* We verify things thrown by the method. They must inherits from + java.lang.Throwable */ + for (mthrows = DECL_FUNCTION_THROWS (method); + mthrows; mthrows = TREE_CHAIN (mthrows)) + { + if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node)) + parse_error_context + (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be " + "a subclass of class `java.lang.Throwable'", + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows))))); + } + sig = build_java_argument_signature (TREE_TYPE (method)); found = lookup_argument_method (super_class, DECL_NAME (method), sig); - if (! found) - continue; + + /* Nothing overrides or it's a private method. */ + if (!found) + continue; + if (METHOD_PRIVATE (found)) + { + found = NULL_TREE; + continue; + } + + /* If found wasn't verified, it's DECL_NAME won't be set properly. + We set it temporarily for the sake of the error report. */ + saved_found_wfl = DECL_NAME (found); + reset_method_name (found); + /* Can't override a method with the same name and different return types. */ if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method))) - parse_warning_context - (method_wfl, - "Method `%s' redefined with different return type in class `%s'", - lang_printable_name (found), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + { + char *t = strdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), + 0)); + parse_error_context + (method_wfl, + "Method `%s' was defined with return type `%s' in class `%s'", + lang_printable_name (found, 0), t, + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + free (t); + } /* Can't override final. Can't override static. */ if (METHOD_FINAL (found) || METHOD_STATIC (found)) @@ -6276,7 +7186,7 @@ java_check_regular_methods (class_decl) (method_wfl, "%s methods can't be overriden. Method `%s' is %s in class `%s'", (METHOD_FINAL (found) ? "Final" : "Static"), - lang_printable_name (found), + lang_printable_name (found, 0), (METHOD_FINAL (found) ? "final" : "static"), IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); @@ -6289,94 +7199,164 @@ java_check_regular_methods (class_decl) (method_wfl, "Instance methods can't be overriden by a static method. Method " "`%s' is an instance method in class `%s'", - lang_printable_name (found), + lang_printable_name (found, 0), IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); continue; } - /* Overriding/hiding public must be public or - overriding/hiding protected must be protected or public */ - if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method)) || - (METHOD_PROTECTED (found) - && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))) + + aflags = get_access_flags_from_decl (found); + /* - Overriding/hiding public must be public + - Overriding/hiding protected must be protected or public + - If the overriden or hidden method has default (package) + access, then the overriding or hiding method must not be + private; otherwise, a compile-time error occurs */ + if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method)) + || (METHOD_PROTECTED (found) + && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method))) + || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC)) + && METHOD_PRIVATE (method))) { parse_error_context (method_wfl, "Methods can't be overridden to be more private. Method `%s' is " - "%s in class `%s'", lang_printable_name (found), - (METHOD_PUBLIC (found) ? "public" : "protected"), - IDENTIFIER_POINTER - (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + "not %s in class `%s'", lang_printable_name (method, 0), + (METHOD_PUBLIC (method) ? "public" : + (METHOD_PRIVATE (method) ? "private" : "protected")), + IDENTIFIER_POINTER (DECL_NAME + (TYPE_NAME (DECL_CONTEXT (found))))); continue; } + /* Overriding methods must have compatible `throws' clauses on checked + exceptions, if any */ + check_throws_clauses (method, method_wfl, found); + /* If the method has default access in an other package, then - issue a warning that the current method doesn't override the one - that was found elsewhere */ - aflags = get_access_flags_from_decl (found); - if ((!aflags || (aflags > ACC_PROTECTED)) - && !class_in_current_package (DECL_CONTEXT (found))) + issue a warning that the current method doesn't override the + one that was found elsewhere. Do not issue this warning when + the match was found in java.lang.Object. */ + if (DECL_CONTEXT (found) != object_type_node + && (!aflags || (aflags > ACC_PROTECTED)) + && !class_in_current_package (DECL_CONTEXT (found)) + && flag_not_overriding) parse_warning_context (method_wfl, "Method `%s' in class `%s' does not " "override the corresponding method in class `%s', which is " "private to a different package", - lang_printable_name (found), + lang_printable_name (found, 0), IDENTIFIER_POINTER (DECL_NAME (class_decl)), IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); - /* Check on (default) package access. FIXME. */ /* Inheriting multiple methods with the same signature. FIXME */ } - TYPE_METHODS (class) = nreverse (TYPE_METHODS (class)); + /* Don't forget eventual pending found and saved_found_wfl. Take + into account that we might have exited because we saw an + aritifical method as the last entry. */ + + if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl) + DECL_NAME (found) = saved_found_wfl; + + if (!TYPE_NVIRTUALS (class)) + TYPE_METHODS (class) = nreverse (TYPE_METHODS (class)); - if (!seen_constructor) + if (!saw_constructor) { - /* No constructor seen, we craft one, at line 0 */ - int saved_lineno = lineno; - tree meth, decl; - lineno = 0; - meth = make_node (FUNCTION_TYPE); - TREE_TYPE (meth) = void_type_node; - TYPE_ARG_TYPES (meth) = NULL_TREE; - decl = add_method (class, 0, init_identifier_node, - build_java_signature (meth)); + /* No constructor seen, we craft one, at line 0. Since this + operation takes place after we laid methods out + (layout_class_methods), we prepare the its DECL + appropriately. */ + int flags; + tree decl; + + /* If the class is declared PUBLIC, the default constructor is + PUBLIC otherwise it has default access implied by no access + modifiers. */ + flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ? + ACC_PUBLIC : 0); + decl = create_artificial_method (class, flags, void_type_node, + init_identifier_node, end_params_node); DECL_CONSTRUCTOR_P (decl) = 1; - lineno = saved_lineno; + layout_class_method (TREE_TYPE (class_decl), NULL_TREE, decl, NULL_TREE); + } +} + +/* Return a non zero value if the `throws' clause of METHOD (if any) + is incompatible with the `throws' clause of FOUND (if any). */ + +static void +check_throws_clauses (method, method_wfl, found) + tree method, method_wfl, found; +{ + tree mthrows, fthrows; + + /* Can't check these things with class loaded from bytecode. FIXME */ + if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found))) + return; + + for (mthrows = DECL_FUNCTION_THROWS (method); + mthrows; mthrows = TREE_CHAIN (mthrows)) + { + /* We don't verify unchecked expressions */ + if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows))) + continue; + /* Checked expression must be compatible */ + for (fthrows = DECL_FUNCTION_THROWS (found); + fthrows; fthrows = TREE_CHAIN (fthrows)) + if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows))) + break; + if (!fthrows) + { + parse_error_context + (method_wfl, "Invalid checked exception class `%s' in " + "`throws' clause. The exception must be a subclass of an " + "exception thrown by `%s' from class `%s'", + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))), + lang_printable_name (found, 0), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + } } } /* Check abstract method of interface INTERFACE */ static void -java_check_abstract_methods (interface) - tree interface; +java_check_abstract_methods (interface_decl) + tree interface_decl; { int i, n; tree method, basetype_vec, found; + tree interface = TREE_TYPE (interface_decl); for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method)) { - char *csig; - tree name = DECL_NAME (method); + tree method_wfl = DECL_NAME (method); /* 2- Check for double definition inside the defining interface */ if (check_method_redefinition (interface, method)) continue; /* 3- Overriding is OK as far as we preserve the return type and - the thrown exceptions */ + the thrown exceptions (FIXME) */ found = lookup_java_interface_method2 (interface, method); if (found) { + char *t; + tree saved_found_wfl = DECL_NAME (found); + reset_method_name (found); + t = strdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0)); parse_error_context - (lookup_cl (method), - "Method `%s' previously defined in interface `%s' is " - "redefined with different return type in interface `%s'", - lang_printable_name (found), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface)))); + (method_wfl, + "Method `%s' was defined with return type `%s' in class `%s'", + lang_printable_name (found, 0), t, + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + free (t); continue; + + DECL_NAME (found) = saved_found_wfl; } } @@ -6398,41 +7378,27 @@ java_check_abstract_methods (interface) found = lookup_java_interface_method2 (interface, sub_interface_method); if (found && (found != sub_interface_method)) - parse_error_context - (lookup_cl (sub_interface_method), - "Interface `%s' inherits method `%s' from interface `%s'. This " - "method is redefined with a different return " - "type in interface `%s'", - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))), - lang_printable_name (found), - IDENTIFIER_POINTER - (DECL_NAME (TYPE_NAME (DECL_CONTEXT (sub_interface_method)))), - IDENTIFIER_POINTER - (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + { + tree saved_found_wfl = DECL_NAME (found); + reset_method_name (found); + parse_error_context + (lookup_cl (sub_interface_method), + "Interface `%s' inherits method `%s' from interface `%s'. " + "This method is redefined with a different return type in " + "interface `%s'", + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))), + lang_printable_name (found, 0), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME + (DECL_CONTEXT (sub_interface_method)))), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + DECL_NAME (found) = saved_found_wfl; + } } } } -/* Check the method on all the defined classes. Should be done to the - classes declared in the compilation unit only. FIXME */ - -void -java_check_methods () -{ - - tree current; - for (current = ctxp->class_list; current; current = TREE_CHAIN (current)) - if (CLASS_FROM_SOURCE_P (TREE_TYPE (current))) - { - tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current)); - - if (CLASS_INTERFACE (TYPE_NAME (class))) - java_check_abstract_methods (class); - else - java_check_regular_methods (current); - } -} - /* Lookup methods in interfaces using their name and partial signature. Return a matching method only if their types differ. */ @@ -6474,9 +7440,12 @@ lookup_java_method2 (clas, method_decl, do_interface) tree clas, method_decl; int do_interface; { - tree method, method_signature, method_name, method_type; + tree method, method_signature, method_name, method_type, name; + method_signature = build_java_argument_signature (TREE_TYPE (method_decl)); - method_name = DECL_NAME (method_decl); + name = DECL_NAME (method_decl); + method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ? + EXPR_WFL_NODE (name) : name); method_type = TREE_TYPE (TREE_TYPE (method_decl)); while (clas != NULL_TREE) @@ -6485,12 +7454,12 @@ lookup_java_method2 (clas, method_decl, do_interface) method != NULL_TREE; method = TREE_CHAIN (method)) { tree method_sig = build_java_argument_signature (TREE_TYPE (method)); - if (DECL_NAME (method) == method_name + tree name = DECL_NAME (method); + if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ? + EXPR_WFL_NODE (name) : name) == method_name && method_sig == method_signature && TREE_TYPE (TREE_TYPE (method)) != method_type) - { - return method; - } + return method; } clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas)); } @@ -6579,74 +7548,26 @@ find_in_imports (class_type) { TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import)); QUALIFIED_P (TYPE_NAME (class_type)) = 1; - return check_pkg_class_access (TYPE_NAME (class_type), - TREE_PURPOSE (import)); } return 0; } -/* Process a import on demand statement (lazy) */ - static int -read_import_entry (jcf, dirp, returned_name) - JCF *jcf; - DIR *dirp; - char **returned_name; +note_possible_classname (name, len) + char *name; + int len; { - if (dirp) - { - struct dirent *direntp = readdir (dirp); - if (!direntp) - { - *returned_name = NULL; - return 0; - } - else - { - *returned_name = direntp->d_name; - return (strlen (direntp->d_name)); - } - } + tree node; + if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0) + len = len - 5; + else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0) + len = len - 6; else - { - int current_dir_len = strlen (jcf->classname); - char *current_entry; - int current_entry_len; - - /* Here we read a zip directory as a file directory. The files - we're selecting must have the same root than the directory - we're examining. */ - - ZipDirectory *zipd = (ZipDirectory *)jcf->zipd; - - while (zipd) - { - current_entry = ZIPDIR_FILENAME (zipd); - current_entry_len = zipd->filename_length; - while (current_entry_len && current_entry [current_entry_len] != '/') - current_entry_len--; - /* If the path of the current file doesn't match the directory we're - scanning, that the end of the search */ - current_entry_len++; - if (strncmp (jcf->classname, current_entry, current_dir_len)) - { - *returned_name = NULL; - return 0; - } - /* Ok, we have at least the same path. The position of the last '/' - of the current file we're examining should match the size of - name of the directory we're browsing, otherwise that an entry - belonging to a sub directory, we want to skip it. */ - if (current_entry_len != current_dir_len) - zipd = ZIPDIR_NEXT (zipd); - else - { - jcf->zipd = ZIPDIR_NEXT (zipd); /* Prepare next read */ - *returned_name = ¤t_entry [current_entry_len]; - return (zipd->filename_length - current_entry_len); - } - } - } + return 0; + node = ident_subst (name, len, "", '/', '.', ""); + IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */ + QUALIFIED_P (node) = 1; /* As soon as we turn / into . */ + return 1; } /* Read a import directory, gathering potential match for further type @@ -6657,30 +7578,104 @@ static void read_import_dir (wfl) tree wfl; { - char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)); - int name_len = IDENTIFIER_LENGTH (EXPR_WFL_NODE (wfl)), reclen; + tree package_id = EXPR_WFL_NODE (wfl); + char *package_name = IDENTIFIER_POINTER (package_id); + int package_length = IDENTIFIER_LENGTH (package_id); DIR *dirp = NULL; - tree dirname = ident_subst (name, name_len, "", '.', '/', ""); - JCF jcfr, *jcf, *saved_jcf = current_jcf; - char *founddirname, *d_name; - struct ZipFileCache zip_cache; + JCF *saved_jcf = current_jcf; + + int found = 0; + int k; + void *entry; + struct buffer filename[1]; + + + if (IS_AN_IMPORT_ON_DEMAND_P (package_id)) + return; + IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1; - jcf = &jcfr; - if (!classpath) - fix_classpath (); - if (!(founddirname = find_class (name, name_len, jcf, 0))) - fatal ("Can't import `%s'", name); - if (jcf->outofsynch) - jcf_out_of_synch (jcf); - if (jcf->seen_in_zip) - jcf->zipd = ZIPDIR_NEXT ((ZipDirectory *)jcf->zipd); + BUFFER_INIT (filename); + buffer_grow (filename, package_length + 100); - else if (founddirname && (dirp = opendir (founddirname))) + for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry)) { - readdir (dirp); readdir (dirp); + char *entry_name = jcf_path_name (entry); + int entry_length = strlen (entry_name); + if (jcf_path_is_zipfile (entry)) + { + ZipFile *zipf; + buffer_grow (filename, entry_length); + memcpy (filename->data, entry_name, entry_length - 1); + filename->data[entry_length-1] = '\0'; + zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry)); + if (zipf == NULL) + error ("malformed .zip archive in CLASSPATH: %s", entry_name); + else + { + ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory; + BUFFER_RESET (filename); + for (k = 0; k < package_length; k++) + { + char ch = package_name[k]; + *filename->ptr++ = ch == '.' ? '/' : ch; + } + *filename->ptr++ = '/'; + + for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd)) + { + char *current_entry = ZIPDIR_FILENAME (zipd); + int current_entry_len = zipd->filename_length; + + if (current_entry_len >= BUFFER_LENGTH (filename) + && strncmp (filename->data, current_entry, + BUFFER_LENGTH (filename)) != 0) + continue; + found |= note_possible_classname (current_entry, + current_entry_len); + } + } + } + else + { + BUFFER_RESET (filename); + buffer_grow (filename, entry_length + package_length + 4); + strcpy (filename->data, entry_name); + filename->ptr = filename->data + entry_length; + for (k = 0; k < package_length; k++) + { + char ch = package_name[k]; + *filename->ptr++ = ch == '.' ? '/' : ch; + } + *filename->ptr = '\0'; + + dirp = opendir (filename->data); + if (dirp == NULL) + continue; + *filename->ptr++ = '/'; + for (;;) + { + int len; + char *d_name; + struct dirent *direntp = readdir (dirp); + if (!direntp) + break; + d_name = direntp->d_name; + len = strlen (direntp->d_name); + buffer_grow (filename, len+1); + strcpy (filename->ptr, d_name); + found |= note_possible_classname (filename->data + entry_length, + package_length+len+1); + } + if (dirp) + closedir (dirp); + } } - if (!founddirname && !dirp) + free (filename->data); + + /* Here we should have a unified way of retrieving an entry, to be + indexed. */ + if (!found) { static int first = 1; if (first) @@ -6688,55 +7683,17 @@ read_import_dir (wfl) char buffer [256]; sprintf (buffer, "Can't find default package `%s'. Check " "the CLASSPATH environment variable and the access to the " - "archives.", name); + "archives.", package_name); error (buffer); java_error_count++; first = 0; } else - parse_error_context (wfl, "Package `%s' not found in import", name); + parse_error_context (wfl, "Package `%s' not found in import", + package_name); current_jcf = saved_jcf; return; } - - /* Here we should have a unified way of retrieving an entry, to be - indexed. */ - while ((reclen = read_import_entry (jcf, dirp, &d_name))) - { - int java_or_class = 0; - int len; - if ((reclen > 5) - && !strcmp (&d_name [reclen-5], ".java")) - { - java_or_class = 1; - len = reclen - 5; - } - - if (!java_or_class && (reclen > 6) && - !strcmp (&d_name [reclen-6], ".class")) - { - java_or_class = 2; - len = reclen - 6; - } - - if (java_or_class) - { - char *id_name; - tree node, old; - - obstack_grow (&temporary_obstack, name, name_len); - obstack_1grow (&temporary_obstack, '/'); - obstack_grow0 (&temporary_obstack, d_name, len); - id_name = obstack_finish (&temporary_obstack); - - node = get_identifier (id_name); - IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */ - QUALIFIED_P (node) = 1; /* As soon as we turn / into . */ - } - } - if (dirp) - closedir (dirp); - current_jcf = saved_jcf; } @@ -6755,11 +7712,10 @@ find_in_imports_on_demand (class_type) for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import)) { char *id_name; - tree found; obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))), IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import)))); - obstack_1grow (&temporary_obstack, '/'); + obstack_1grow (&temporary_obstack, '.'); obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (TYPE_NAME (class_type)), IDENTIFIER_LENGTH (TYPE_NAME (class_type))); @@ -6792,9 +7748,7 @@ find_in_imports_on_demand (class_type) tree decl; int saved_lineno = lineno; lineno = EXPR_WFL_LINENO (cl); - TYPE_NAME (class_type) = ident_subst (IDENTIFIER_POINTER (node_to_use), - IDENTIFIER_LENGTH (node_to_use), - "", '/', '.', ""); + TYPE_NAME (class_type) = node_to_use; QUALIFIED_P (TYPE_NAME (class_type)) = 1; decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)); /* If there is no DECL set for the class or if the class isn't @@ -6809,6 +7763,49 @@ find_in_imports_on_demand (class_type) return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */ } +static tree +resolve_package (pkg, next) + tree pkg, *next; +{ + tree type_name = NULL_TREE; + char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg)); + + /* The trick is to determine when the package name stops and were + the name of something contained in the package starts. Then we + return a fully qualified name of what we want to get. */ + + /* Do a quick search on well known package names */ + if (!strncmp (name, "java.lang.reflect", 17)) + { + *next = + TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)))); + type_name = lookup_package_type (name, 17); + } + else if (!strncmp (name, "java.lang", 9)) + { + *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))); + type_name = lookup_package_type (name, 9); + } + else + return NULL_TREE; /* FIXME, search all imported packages. */ + + return type_name; +} + +static tree +lookup_package_type (name, from) + char *name; + int from; +{ + char subname [128]; + char *sub = &name[from+1]; + while (*sub != '.' && *sub) + sub++; + strncpy (subname, name, sub-name); + subname [sub-name] = '\0'; + return get_identifier (subname); +} + /* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no access violations were found, 1 otherwise. */ @@ -6818,7 +7815,6 @@ check_pkg_class_access (class_name, cl) tree cl; { tree type; - int access; if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name)) return 0; @@ -6828,6 +7824,13 @@ check_pkg_class_access (class_name, cl) if (!CLASS_PUBLIC (TYPE_NAME (type))) { + /* Access to a private class within the same package is + allowed. */ + tree l, r; + breakdown_qualified (&l, &r, class_name); + if (l == ctxp->package) + return 0; + parse_error_context (cl, "Can't access %s `%s'. Only public classes and interfaces in " "other packages can be accessed", @@ -6846,85 +7849,100 @@ declare_local_variables (modifier, type, vlist) tree type; tree vlist; { - tree decl, current, returned_type, type_wfl, init_stmt = NULL_TREE; + tree decl, current, saved_type; + tree type_wfl = NULL_TREE; int must_chain = 0; - /* Push a new block if statement were seen between the last time we + /* Push a new block if statements were seen between the last time we pushed a block and now. Keep a cound of block to close */ - if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl))) + if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl))) { - tree body = DECL_FUNCTION_BODY (current_function_decl); + tree body = GET_CURRENT_BLOCK (current_function_decl); tree b = enter_block (); - BLOCK_EXPR_ORIGIN(b) = body; + BLOCK_EXPR_ORIGIN (b) = body; } if (modifier) { int i; for (i = 0; i <= 10; i++) if (1 << i & modifier) break; - parse_error_context - (ctxp->modifier_ctx [i], - (modifier == ACC_FINAL ? - "Unsupported JDK1.1 `final' locals" : - "Only `final' is allowed as a local variables modifier")); - return; - } - - if (unresolved_type_p (type, &returned_type)) - { - if (returned_type) - type = returned_type; + if (modifier == ACC_FINAL) + { + if (flag_static_local_jdk1_1) + parse_warning_context (ctxp->modifier_ctx [i], + "Unsupported JDK1.1 `final' local variable " + "(treated as non final)"); + } else { - type_wfl = type; - type = obtain_incomplete_type (type); - must_chain = 1; + parse_error_context + (ctxp->modifier_ctx [i], + "Only `final' is allowed as a local variables modifier"); + return; } } - - for (current = vlist; current; current = TREE_CHAIN (current)) + + /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will + hold the TYPE value if a new incomplete has to be created (as + opposed to being found already existing and reused). */ + SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain); + + /* If TYPE is fully resolved and we don't have a reference, make one */ + PROMOTE_RECORD_IF_COMPLETE (type, must_chain); + + /* Go through all the declared variables */ + for (current = vlist, saved_type = type; current; + current = TREE_CHAIN (current), type = saved_type) { + tree other, real_type; tree wfl = TREE_PURPOSE (current); tree name = EXPR_WFL_NODE (wfl); tree init = TREE_VALUE (current); - tree other = lookup_name_in_blocks (name); - /* Don't try to use an INIT statement when an error was found */ - if (init && java_error_count) - init = NULL_TREE; + /* Process NAME, as it may specify extra dimension(s) for it */ + type = build_array_from_name (type, type_wfl, name, &name); - if (other) - parse_error_context - (wfl, "Variable `%s' is already defined in this method and was " - "declared `%s %s' in line %d", - IDENTIFIER_POINTER (name), lang_printable_name (TREE_TYPE (other)), - IDENTIFIER_POINTER (name), DECL_SOURCE_LINE (other)); - else + /* Variable redefinition check */ + if ((other = lookup_name_in_blocks (name))) { - if (!must_chain && TREE_CODE (type) == RECORD_TYPE) - type = promote_type (type); - /* Never layout this decl. This will be done when its scope - will be entered */ - decl = build_decl_no_layout (VAR_DECL, name, type); - BLOCK_CHAIN_DECL (decl); + variable_redefinition_error (wfl, name, TREE_TYPE (other), + DECL_SOURCE_LINE (other)); + continue; + } - /* Add the initialization function to the current function's code */ - if (init) - { - tree wfl; - MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1; - java_method_add_stmt - (current_function_decl, - build_debugable_stmt (EXPR_WFL_LINECOL (init), init)); - } + /* Type adjustment. We may have just readjusted TYPE because + the variable specified more dimensions. Make sure we have + a reference if we can and don't have one already. */ + PROMOTE_RECORD_IF_COMPLETE (type, must_chain); - if (must_chain) - { - jdep *dep; - register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type); - dep = CLASSD_LAST (ctxp->classd_list); - JDEP_GET_PATCH (dep) = &TREE_TYPE (decl); - } + real_type = GET_REAL_TYPE (type); + /* Never layout this decl. This will be done when its scope + will be entered */ + decl = build_decl (VAR_DECL, name, real_type); + BLOCK_CHAIN_DECL (decl); + + /* Don't try to use an INIT statement when an error was found */ + if (init && java_error_count) + init = NULL_TREE; + + /* Add the initialization function to the current function's code */ + if (init) + { + /* Name might have been readjusted */ + EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name; + MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1; + java_method_add_stmt (current_function_decl, + build_debugable_stmt (EXPR_WFL_LINECOL (init), + init)); + } + + /* Setup dependency the type of the decl */ + if (must_chain) + { + jdep *dep; + register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type); + dep = CLASSD_LAST (ctxp->classd_list); + JDEP_GET_PATCH (dep) = &TREE_TYPE (decl); } } SOURCE_FRONTEND_DEBUG (("Defined locals")); @@ -6940,25 +7958,24 @@ source_start_java_method (fndecl) tree parm_decl; int i; - extern tree current_binding_level; current_function_decl = fndecl; /* New scope for the function */ enter_block (); for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0; - tem != NULL_TREE; tem = TREE_CHAIN (tem), i++) + tem != end_params_node; tem = TREE_CHAIN (tem), i++) { tree type = TREE_VALUE (tem); tree name = TREE_PURPOSE (tem); - /* If type is incomplete. Layout can't take place - now. Create an incomplete decl and ask for the decl to be - patched later */ + /* If type is incomplete. Create an incomplete decl and ask for + the decl to be patched later */ if (INCOMPLETE_TYPE_P (type)) { jdep *jdep; - parm_decl = build_decl_no_layout (PARM_DECL, name, type); - + tree real_type = GET_REAL_TYPE (type); + parm_decl = build_decl (PARM_DECL, name, real_type); + type = obtain_incomplete_type (type); register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type); jdep = CLASSD_LAST (ctxp->classd_list); JDEP_MISC (jdep) = name; @@ -6975,6 +7992,47 @@ source_start_java_method (fndecl) DECL_ARG_SLOT_COUNT (current_function_decl) = i; } +/* Called during parsing. Creates an artificial method declaration. */ + +static tree +create_artificial_method (class, flags, type, name, args) + tree class; + int flags; + tree type, name, args; +{ + int saved_lineno = lineno; + tree mdecl; + + lineno = 0; + mdecl = make_node (FUNCTION_TYPE); + TREE_TYPE (mdecl) = type; + TYPE_ARG_TYPES (mdecl) = args; + mdecl = add_method (class, flags, name, build_java_signature (mdecl)); + lineno = saved_lineno; + DECL_ARTIFICIAL (mdecl) = 1; + return mdecl; +} + +/* Starts the body if an artifical method. */ + +static void +start_artificial_method_body (mdecl) + tree mdecl; +{ + DECL_SOURCE_LINE (mdecl) = 1; + DECL_SOURCE_LINE_MERGE (mdecl, 1); + source_start_java_method (mdecl); + enter_block (); +} + +static void +end_artificial_method_body (mdecl) + tree mdecl; +{ + BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block (); + exit_block (); +} + /* Called during expansion. Push decls formerly built from argument list so they're usable during expansion. */ @@ -6983,9 +8041,7 @@ expand_start_java_method (fndecl) tree fndecl; { tree tem, *ptr; - tree parm_decl; - extern tree current_binding_level; current_function_decl = fndecl; announce_function (fndecl); @@ -6995,10 +8051,15 @@ expand_start_java_method (fndecl) while (tem) { tree next = TREE_CHAIN (tem); - DECL_ARG_TYPE (tem) = TREE_TYPE (tem); + tree type = TREE_TYPE (tem); +#ifdef PROMOTE_PROTOTYPES + if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node) + && INTEGRAL_TYPE_P (type)) + type = integer_type_node; +#endif + DECL_ARG_TYPE (tem) = type; layout_decl (tem, 0); pushdecl (tem); - INITIALIZED_P (tem) = 1; /* Parms are initialized */ *ptr = tem; ptr = &TREE_CHAIN (tem); tem = next; @@ -7006,7 +8067,6 @@ expand_start_java_method (fndecl) *ptr = NULL_TREE; pushdecl_force_head (DECL_ARGUMENTS (fndecl)); lineno = DECL_SOURCE_LINE_FIRST (fndecl); - complete_start_java_method (fndecl); } /* Terminate a function and expand its body. */ @@ -7019,6 +8079,9 @@ source_end_java_method () java_parser_context_save_global (); lineno = ctxp->last_ccb_indent1; + /* Set EH language codes */ + java_set_exception_lang_code (); + /* Generate function's code */ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) && ! flag_emit_class_files) @@ -7033,6 +8096,8 @@ source_end_java_method () if (! flag_emit_class_files) { lineno = DECL_SOURCE_LINE_LAST (fndecl); + /* Emit catch-finally clauses */ + emit_handlers (); expand_function_end (input_filename, lineno, 0); /* Run the optimizers and output assembler code for this function. */ @@ -7051,17 +8116,24 @@ tree java_method_add_stmt (fndecl, expr) tree fndecl, expr; { - tree body = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)); - tree node; + return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr); +} +static tree +add_stmt_to_block (b, type, stmt) + tree b, type, stmt; +{ + tree body = BLOCK_EXPR_BODY (b), c; + if (java_error_count) return body; - if ((node = add_stmt_to_compound (body, NULL_TREE, expr)) == body) + + if ((c = add_stmt_to_compound (body, type, stmt)) == body) return body; - BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = node; - TREE_SIDE_EFFECTS (node) = 1; - return node; + BLOCK_EXPR_BODY (b) = c; + TREE_SIDE_EFFECTS (c) = 1; + return c; } /* Add STMT to EXISTING if possible, otherwise create a new @@ -7071,39 +8143,103 @@ static tree add_stmt_to_compound (existing, type, stmt) tree existing, type, stmt; { - tree node; - - if (existing && (TREE_CODE (existing) == COMPOUND_EXPR) - && TREE_OPERAND (existing, 1) == size_zero_node) - { - TREE_OPERAND (existing, 1) = stmt; - TREE_TYPE (existing) = type; - return existing; - } - else if (existing) - node = build (COMPOUND_EXPR, type, existing, stmt); + if (existing) + return build (COMPOUND_EXPR, type, existing, stmt); else - node = build (COMPOUND_EXPR, type, stmt, size_zero_node); - - return node; + return stmt; } /* Hold THIS for the scope of the current public method decl. */ static tree current_this; -/* Layout all class found during parsing */ +void java_layout_seen_class_methods () +{ + tree previous_list = all_class_list; + tree end = NULL_TREE; + tree current; + + while (1) + { + for (current = previous_list; + current != end; current = TREE_CHAIN (current)) + layout_class_methods (TREE_TYPE (TREE_VALUE (current))); + + if (previous_list != all_class_list) + { + end = previous_list; + previous_list = all_class_list; + } + else + break; + } +} + +/* Layout the methods of all classes loaded in one way on an + other. Check methods of source parsed classes. Then reorder the + fields and layout the classes or the type of all source parsed + classes */ void java_layout_classes () { tree current; - for (current = ctxp->class_list; current; current = TREE_CHAIN (current)) + int save_error_count = java_error_count; + + /* Layout the methods of all classes seen so far */ + java_layout_seen_class_methods (); + java_parse_abort_on_error (); + all_class_list = NULL_TREE; + + /* Then check the methods of all parsed classes */ + for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current)) + if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current)))) + CHECK_METHODS (TREE_VALUE (current)); + java_parse_abort_on_error (); + + for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current)) { - current_class = TREE_TYPE (current); - TYPE_FIELDS (current_class) = nreverse (TYPE_FIELDS (current_class)); - if (!TYPE_SIZE (current_class)) - safe_layout_class (current_class); + current_class = TREE_TYPE (TREE_VALUE (current)); + + /* Reverse the fields, but leave the dummy field in front. + Fields are already ordered for Object and Class */ + if (TYPE_FIELDS (current_class) && current_class != object_type_node + && current_class != class_type_node) + { + /* If the dummy field is there, reverse the right fields and + just layout the type for proper fields offset */ + if (!DECL_NAME (TYPE_FIELDS (current_class))) + { + tree fields = TYPE_FIELDS (current_class); + TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields)); + TYPE_SIZE (current_class) = NULL_TREE; + layout_type (current_class); + } + /* We don't have a dummy field, we need to layout the class, + after having reversed the fields */ + else + { + TYPE_FIELDS (current_class) = + nreverse (TYPE_FIELDS (current_class)); + TYPE_SIZE (current_class) = NULL_TREE; + layout_class (current_class); + } + } + else + layout_class (current_class); + + /* From now on, the class is considered completely loaded */ + CLASS_LOADED_P (current_class) = 1; + + /* Error reported by the caller */ + if (java_error_count) + return; } + + /* We might have reloaded classes durign the process of laying out + classes for code generation. We must layout the methods of those + late additions, as constructor checks might use them */ + java_layout_seen_class_methods (); + java_parse_abort_on_error (); } /* Expand all methods in all registered classes. */ @@ -7115,16 +8251,24 @@ java_complete_expand_methods () for (current = ctxp->class_list; current; current = TREE_CHAIN (current)) { - extern tree current_constant_pool_data_ref; tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current)); tree decl; - int saved_lineno; current_class = TREE_TYPE (current); /* Initialize a new constant pool */ init_outgoing_cpool (); + /* We want <clinit> (if any) to be processed first. */ + decl = tree_last (TYPE_METHODS (class_type)); + if (decl && DECL_NAME (decl) == clinit_identifier_node) + { + tree list = nreverse (TYPE_METHODS (class_type)); + list = TREE_CHAIN (list); + TREE_CHAIN (decl) = NULL_TREE; + TYPE_METHODS (class_type) = chainon (decl, nreverse (list)); + } + /* Don't process function bodies in interfaces */ if (!CLASS_INTERFACE (TYPE_NAME (current_class))) for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl)) @@ -7143,91 +8287,204 @@ java_complete_expand_methods () restore_line_number_status (0); } } - else + else if (METHOD_ABSTRACT (decl) || METHOD_NATIVE (decl)) + continue; + else java_complete_expand_method (decl); } + /* Now verify constructor circularity (stop after the first one + we find) */ + if (!CLASS_INTERFACE (TYPE_NAME (current_class))) + for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl)) + if (DECL_CONSTRUCTOR_P (decl) && + verify_constructor_circularity (decl, decl)) + break; + /* Make the class data, register it and run the rest of decl compilation on it */ - if (!java_error_count && ! flag_emit_class_files) + if (!java_error_count) { - make_class_data (current_class); - register_class (); - rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0); + if (flag_emit_class_files) + write_classfile (current_class); + if (flag_emit_xref) + expand_xref (current_class); + else if (! flag_syntax_only) + finish_class (current_class); } } } +/* Hold a list of catch clauses list. The first element of this list is + the list of the catch clauses of the currently analysed try block. */ +static tree currently_caught_type_list; + /* Complete and expand a method. */ static void java_complete_expand_method (mdecl) tree mdecl; { - tree node; - jdep *current; - int no_ac_found = 1; - - /* We generate some code for an empty constructor */ - if (DECL_CONSTRUCTOR_P (mdecl) && !DECL_FUNCTION_BODY (mdecl)) - { - tree arg_list, func, call; - tree method_type = TREE_TYPE (mdecl); - tree class_type = CLASS_TO_HANDLE_TYPE (current_class); - tree self_type = (CLASSTYPE_SUPER (class_type) ? - CLASSTYPE_SUPER (class_type) : class_type); - tree method_signature = - TYPE_LANG_SPECIFIC (method_type)->signature; - tree method = - lookup_java_constructor (CLASS_TO_HANDLE_TYPE (self_type), - method_signature); - tree block, compound; - - /* Fixe the begining/ending lines of the method so that with - no_line_numbers set to 1 it doesn't generate debug info at - line 1 for this artificial constructor. */ - DECL_SOURCE_LINE (mdecl) = 1; - DECL_SOURCE_LINE_MERGE (mdecl, 1); - source_start_java_method (mdecl); - arg_list = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)); - enter_block (); - func = build_known_method_ref (method, method_type, self_type, - method_signature, arg_list); - - if (! flag_emit_class_files) - func = build1 (NOP_EXPR, build_pointer_type (method_type), func); - call = build (CALL_EXPR, TREE_TYPE (method_type), func, - build_tree_list (NULL_TREE, arg_list), NULL_TREE); - TREE_SIDE_EFFECTS (call) = 1; - call = build_class_init (self_type, call); - compound = java_method_add_stmt (mdecl, call); - block = exit_block (); - BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = block; - /* The function decl, its block and the compound statement - within this block are all of void type. */ - TREE_TYPE (block) = TREE_TYPE (compound) = - TREE_TYPE (DECL_FUNCTION_BODY (mdecl)) = void_type_node; - exit_block (); - no_ac_found = 0; - } + /* Fix constructors before expanding them */ + if (DECL_CONSTRUCTOR_P (mdecl)) + fix_constructors (mdecl); + /* Expand functions that have a body */ if (DECL_FUNCTION_BODY (mdecl)) { + tree fbody = DECL_FUNCTION_BODY (mdecl); + tree block_body = BLOCK_EXPR_BODY (fbody); expand_start_java_method (mdecl); + build_result_decl (mdecl); current_this = (!METHOD_STATIC (mdecl) ? BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE); - if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) && no_ac_found) - java_complete_tree (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl))); + /* Purge the `throws' list of unchecked exceptions */ + purge_unchecked_exceptions (mdecl); + + /* Install exceptions thrown with `throws' */ + PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl)); + + if (block_body != NULL_TREE) + { + /* Prevent the use of `this' inside <clinit> */ + if (DECL_NAME (current_function_decl) == clinit_identifier_node) + ctxp->explicit_constructor_p = 1; + + block_body = java_complete_tree (block_body); + check_for_initialization (block_body); + ctxp->explicit_constructor_p = 0; + } + BLOCK_EXPR_BODY (fbody) = block_body; + + if ((block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body)) + && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE) + missing_return_error (current_function_decl); + + complete_start_java_method (mdecl); + /* Don't go any further if we've found error(s) during the expansion */ if (!java_error_count) source_end_java_method (); + else + { + pushdecl_force_head (DECL_ARGUMENTS (mdecl)); + poplevel (1, 0, 1); + } + + /* Pop the exceptions and sanity check */ + POP_EXCEPTIONS(); + if (currently_caught_type_list) + fatal ("Exception list non empty - java_complete_expand_method"); } } +/* Craft a body for default constructor. Patch existing constructor + bodies with call to super() and field initialization statements if + necessary. */ + +static void +fix_constructors (mdecl) + tree mdecl; +{ + tree body = DECL_FUNCTION_BODY (mdecl); + + if (!body) + { + /* The constructor body must be crafted by hand. It's the + constructor we defined when we realize we didn't have the + CLASSNAME() constructor */ + + tree compound; + + /* It is an error for the compiler to generate a default + constructor if the superclass doesn't have a constructor that + takes no argument */ + if (verify_constructor_super ()) + { + tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (current_class)); + char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl)); + parse_error_context (lookup_cl (TYPE_NAME (current_class)), + "No constructor matching `%s()' found in " + "class `%s'", n, n); + } + + start_artificial_method_body (mdecl); + + /* We don't generate a super constructor invocation if we're + compiling java.lang.Object. build_super_invocation takes care + of that. */ + compound = java_method_add_stmt (mdecl, build_super_invocation ()); + + end_artificial_method_body (mdecl); + } + /* Search for an explicit constructor invocation */ + else + { + int found = 0; + tree main_block = BLOCK_EXPR_BODY (body); + tree compound = NULL_TREE; + + while (body) + switch (TREE_CODE (body)) + { + case CALL_EXPR: + found = CALL_EXPLICIT_CONSTRUCTOR_P (body); + body = NULL_TREE; + break; + case COMPOUND_EXPR: + case EXPR_WITH_FILE_LOCATION: + body = TREE_OPERAND (body, 0); + break; + case BLOCK: + body = BLOCK_EXPR_BODY (body); + break; + default: + found = 0; + body = NULL_TREE; + } + /* The constructor is missing an invocation of super() */ + if (!found) + compound = add_stmt_to_compound (compound, NULL_TREE, + build_super_invocation ()); + + /* Fix the constructor main block if we're adding extra stmts */ + if (compound) + { + compound = add_stmt_to_compound (compound, NULL_TREE, + BLOCK_EXPR_BODY (main_block)); + BLOCK_EXPR_BODY (main_block) = compound; + } + } +} + +/* Browse constructors in the super class, searching for a constructor + that doesn't take any argument. Return 0 if one is found, 1 + otherwise. */ + +static int +verify_constructor_super () +{ + tree class = CLASSTYPE_SUPER (current_class); + if (!class) + return 0; + + if (class) + { + tree mdecl; + for (mdecl = TYPE_METHODS (class); mdecl; mdecl = TREE_CHAIN (mdecl)) + { + if (DECL_CONSTRUCTOR_P (mdecl) + && TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (mdecl))) == end_params_node) + return 0; + } + } + return 1; +} + /* Expand finals. */ void @@ -7235,6 +8492,31 @@ java_expand_finals () { } +/* Generate code for all context remembered for code generation. */ + +void +java_expand_classes () +{ + int save_error_count = java_error_count; + java_parse_abort_on_error (); + if (!(ctxp = ctxp_for_generation)) + return; + java_layout_classes (); + java_parse_abort_on_error (); + + for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next) + { + ctxp = ctxp_for_generation; + lang_init_source (2); /* Error msgs have method prototypes */ + java_complete_expand_methods (); /* Complete and expand method bodies */ + java_parse_abort_on_error (); + java_expand_finals (); /* Expand and check the finals */ + java_parse_abort_on_error (); + java_check_final (); /* Check unitialized final */ + java_parse_abort_on_error (); + } +} + /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to a tree list node containing RIGHT. Fore coming RIGHTs will be chained to this hook. LOCATION contains the location of the @@ -7250,9 +8532,9 @@ make_qualified_primary (primary, right, location) /* We want to process THIS . xxx symbolicaly, to keep it consistent with the way we're processing SUPER. A THIS from a primary as a different form than a SUPER. Turn THIS into something symbolic */ - if (TREE_CODE (primary) == JAVA_THIS_EXPR) + if (TREE_CODE (primary) == THIS_EXPR) { - wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0); + wfl = build_wfl_node (this_identifier_node); EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary); wfl = make_qualified_name (wfl, right, location); PRIMARY_P (wfl) = 1; @@ -7306,7 +8588,11 @@ make_qualified_name (left, right, location) tree left, right; int location; { - int qualified; +#ifdef USE_COMPONENT_REF + tree node = build (COMPONENT_REF, NULL_TREE, left, right); + EXPR_WFL_LINECOL (node) = location; + return node; +#else tree left_id = EXPR_WFL_NODE (left); tree right_id = EXPR_WFL_NODE (right); tree wfl, merge; @@ -7327,6 +8613,7 @@ make_qualified_name (left, right, location) EXPR_WFL_NODE (left) = merge; return left; +#endif } /* Extract the last identifier component of the qualified in WFL. The @@ -7352,8 +8639,9 @@ cut_identifier_in_qualified (wfl) /* Resolve the expression name NAME. Return its decl. */ static tree -resolve_expression_name (id) +resolve_expression_name (id, orig) tree id; + tree *orig; { tree name = EXPR_WFL_NODE (id); tree decl; @@ -7386,9 +8674,26 @@ resolve_expression_name (id) (TYPE_NAME (current_class)))); return error_mark_node; } + /* Instance variables can't appear as an argument of + an explicit constructor invocation */ + if (!fs && ctxp->explicit_constructor_p) + { + parse_error_context + (id, "Can't reference `%s' before the superclass " + "constructor has been called", IDENTIFIER_POINTER (name)); + return error_mark_node; + } + + /* Otherwise build what it takes to access the field */ decl = build_field_ref ((fs ? NULL_TREE : current_this), current_class, name); - return (fs ? build_class_init (current_class, decl) : decl); + if (fs && !flag_emit_class_files) + decl = build_class_init (current_class, decl); + /* We may be asked to save the real field access node */ + if (orig) + *orig = decl; + /* And we return what we got */ + return decl; } /* Fall down to error report on undefined variable */ } @@ -7396,6 +8701,8 @@ resolve_expression_name (id) /* 6.5.5.2 Qualified Expression Names */ else { + if (orig) + *orig = NULL_TREE; qualify_ambiguous_name (id); /* 15.10.1 Field Access Using a Primary and/or Expression Name */ /* 15.10.2: Accessing Superclass Members using super */ @@ -7437,23 +8744,36 @@ resolve_field_access (qual_wfl, field_decl, field_type) } /* We might have been trying to resolve field.method(). In which case, the resolution is over and decl is the answer */ - else if (DECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl) + else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl) field_ref = decl; - else if (DECL_P (decl)) - { - is_static = DECL_P (decl) && FIELD_STATIC (decl); - field_ref = build_field_ref ((is_static ? NULL_TREE : where_found), - type_found, DECL_NAME (decl)); + else if (JDECL_P (decl)) + { + int static_final_found = 0; + if (!type_found) + type_found = DECL_CONTEXT (decl); + is_static = JDECL_P (decl) && FIELD_STATIC (decl); + if (FIELD_FINAL (decl) + && JPRIMITIVE_TYPE_P (TREE_TYPE (decl)) + && DECL_LANG_SPECIFIC (decl) + && DECL_INITIAL (decl)) + { + field_ref = DECL_INITIAL (decl); + static_final_found = 1; + } + else + field_ref = build_field_ref ((is_static ? NULL_TREE : where_found), + type_found, DECL_NAME (decl)); if (field_ref == error_mark_node) return error_mark_node; - if (is_static) + if (is_static && !static_final_found && !flag_emit_class_files) { field_ref = build_class_init (type_found, field_ref); /* If the static field was identified by an expression that needs to be generated, make the field access a compound expression whose first part of the evaluation of the field selector part. */ - if (where_found && TREE_CODE (where_found) != TYPE_DECL) + if (where_found && TREE_CODE (where_found) != TYPE_DECL + && TREE_CODE (where_found) != RECORD_TYPE) { tree type = QUAL_DECL_TYPE (field_ref); field_ref = build (COMPOUND_EXPR, type, where_found, field_ref); @@ -7466,10 +8786,35 @@ resolve_field_access (qual_wfl, field_decl, field_type) if (field_decl) *field_decl = decl; if (field_type) - *field_type = QUAL_DECL_TYPE (decl); + *field_type = (QUAL_DECL_TYPE (decl) ? + QUAL_DECL_TYPE (decl) : TREE_TYPE (decl)); return field_ref; } +/* If NODE is an access to f static field, strip out the class + initialization part and return the field decl, otherwise, return + NODE. */ + +static tree +strip_out_static_field_access_decl (node) + tree node; +{ + if (TREE_CODE (node) == COMPOUND_EXPR) + { + tree op1 = TREE_OPERAND (node, 1); + if (TREE_CODE (op1) == COMPOUND_EXPR) + { + tree call = TREE_OPERAND (op1, 0); + if (TREE_CODE (call) == CALL_EXPR + && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR + && TREE_OPERAND (TREE_OPERAND (call, 0), 0) + == soft_initclass_node) + return TREE_OPERAND (op1, 1); + } + } + return node; +} + /* 6.5.5.2: Qualified Expression Names */ static int @@ -7482,31 +8827,33 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) int previous_call_static = 0; int is_static; tree decl = NULL_TREE, type = NULL_TREE, q; - *where_found = NULL_TREE; + *type_found = *where_found = NULL_TREE; for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q)) { tree qual_wfl = QUAL_WFL (q); /* 15.10.1 Field Access Using a Primary */ - switch (TREE_CODE (qual_wfl)) { case CALL_EXPR: - case JAVA_NEW_CLASS_EXPR: + case NEW_CLASS_EXPR: /* If the access to the function call is a non static field, build the code to access it. */ - if (DECL_P (decl) && !FIELD_STATIC (decl)) + if (JDECL_P (decl) && !FIELD_STATIC (decl)) { - decl = maybe_access_field (decl, *where_found, type); + decl = maybe_access_field (decl, *where_found, + DECL_CONTEXT (decl)); if (decl == error_mark_node) return 1; } /* And code for the function call */ if (complete_function_arguments (qual_wfl)) return 1; + if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR) + CALL_USING_SUPER (qual_wfl) = 1; *where_found = - patch_method_invocation_stmt (qual_wfl, decl, type, &is_static); + patch_method_invocation (qual_wfl, decl, type, &is_static, NULL); if (*where_found == error_mark_node) return 1; *type_found = type = QUAL_DECL_TYPE (*where_found); @@ -7527,6 +8874,14 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) } continue; + case NEW_ARRAY_EXPR: + *where_found = decl = java_complete_tree (qual_wfl); + if (decl == error_mark_node) + return 1; + *type_found = type = QUAL_DECL_TYPE (decl); + CLASS_LOADED_P (type) = 1; + continue; + case CONVERT_EXPR: *where_found = decl = java_complete_tree (qual_wfl); if (decl == error_mark_node) @@ -7535,10 +8890,18 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) from_cast = 1; continue; + case CONDITIONAL_EXPR: + case STRING_CST: + *where_found = decl = java_complete_tree (qual_wfl); + if (decl == error_mark_node) + return 1; + *type_found = type = QUAL_DECL_TYPE (decl); + continue; + case ARRAY_REF: /* If the access to the function call is a non static field, build the code to access it. */ - if (DECL_P (decl) && !FIELD_STATIC (decl)) + if (JDECL_P (decl) && !FIELD_STATIC (decl)) { decl = maybe_access_field (decl, *where_found, type); if (decl == error_mark_node) @@ -7550,6 +8913,10 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) return 1; type = QUAL_DECL_TYPE (decl); continue; + + default: + /* Fix for -Wall Just go to the next statement. Don't + continue */ } /* If we fall here, we weren't processing a (static) function call. */ @@ -7566,7 +8933,7 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) } /* We have to generate code for intermediate acess */ *where_found = decl = current_this; - type = QUAL_DECL_TYPE (decl); + *type_found = type = QUAL_DECL_TYPE (decl); continue; } @@ -7587,6 +8954,8 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) CLASSTYPE_SUPER (current_class), build_this (EXPR_WFL_LINECOL (qual_wfl))); *where_found = decl = java_complete_tree (node); + if (decl == error_mark_node) + return 1; *type_found = type = QUAL_DECL_TYPE (decl); from_super = from_type = 1; continue; @@ -7596,17 +8965,33 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) assume a variable/class name was meant. */ if (RESOLVE_PACKAGE_NAME_P (qual_wfl)) { - if (from_super || from_cast) - parse_error_context - ((from_cast ? qual_wfl : wfl), - "No variable `%s' defined in class `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)), - lang_printable_name (type)); + tree name = resolve_package (wfl, &q); + if (name) + { + *where_found = decl = resolve_no_layout (name, qual_wfl); + /* We wan't to be absolutely that the class is laid + out. We're going to search something inside it. */ + *type_found = type = TREE_TYPE (decl); + layout_class (type); + from_type = 1; + /* Should be a list, really. FIXME */ + RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 1; + RESOLVE_PACKAGE_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 0; + } else - parse_error_context - (qual_wfl, "Undefined variable or class name: `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl))); - return 1; + { + if (from_super || from_cast) + parse_error_context + ((from_cast ? qual_wfl : wfl), + "No variable `%s' defined in class `%s'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)), + lang_printable_name (type, 0)); + else + parse_error_context + (qual_wfl, "Undefined variable or class name: `%s'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl))); + return 1; + } } /* We have a type name. It's been already resolved when the @@ -7621,11 +9006,12 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) parse_error_context (qual_wfl, "Can't access %s field `%s.%s' from `%s'", java_accstring_lookup (get_access_flags_from_decl (decl)), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))), + GET_TYPE_NAME (type), IDENTIFIER_POINTER (DECL_NAME (decl)), IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)))); return 1; } + check_deprecation (qual_wfl, decl); type = TREE_TYPE (decl); from_type = 1; @@ -7640,36 +9026,69 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) come. Don't do that when processing something after SUPER (we need more thing to be put in place below */ if (!from_super && QUAL_RESOLUTION (q)) - decl = QUAL_RESOLUTION (q); + { + decl = QUAL_RESOLUTION (q); + if (!type) + { + if (!FIELD_STATIC (decl)) + *where_found = current_this; + else + { + *where_found = TREE_TYPE (decl); + if (TREE_CODE (*where_found) == POINTER_TYPE) + *where_found = TREE_TYPE (*where_found); + } + } + } /* We have to search for a field, knowing the type of its container. The flag FROM_TYPE indicates that we resolved the last member of the expression as a type name, which - means that for the resolution of this field, will check - on other errors than if the it was resolved as a member - of an other field. */ + means that for the resolution of this field, we'll look + for other errors than if it was resolved as a member of + an other field. */ else { int is_static; + tree field_decl_type; /* For layout */ + if (!from_type && !JREFERENCE_TYPE_P (type)) { parse_error_context (qual_wfl, "Attempt to reference field `%s' in `%s %s'", IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)), - lang_printable_name (type), + lang_printable_name (type, 0), IDENTIFIER_POINTER (DECL_NAME (field_decl))); return 1; } - if (!(field_decl = - lookup_field_wrapper (type, EXPR_WFL_NODE (qual_wfl)))) + field_decl = lookup_field_wrapper (type, + EXPR_WFL_NODE (qual_wfl)); + if (field_decl == NULL_TREE) { parse_error_context - (qual_wfl, "No variable `%s' defined in class `%s'", + (qual_wfl, "No variable `%s' defined in type `%s'", IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); + GET_TYPE_NAME (type)); return 1; } + if (field_decl == error_mark_node) + return 1; + + /* Layout the type of field_decl, since we may need + it. Don't do primitive types or loaded classes. The + situation of non primitive arrays may not handled + properly here. FIXME */ + if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE) + field_decl_type = TREE_TYPE (TREE_TYPE (field_decl)); + else + field_decl_type = TREE_TYPE (field_decl); + if (!JPRIMITIVE_TYPE_P (field_decl_type) + && !CLASS_LOADED_P (field_decl_type) + && !TYPE_ARRAY_P (field_decl_type)) + resolve_and_layout (field_decl_type, NULL_TREE); + if (TYPE_ARRAY_P (field_decl_type)) + CLASS_LOADED_P (field_decl_type) = 1; /* Check on accessibility here */ if (not_accessible_p (type, field_decl, from_super)) @@ -7679,12 +9098,13 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) "Can't access %s field `%s.%s' from `%s'", java_accstring_lookup (get_access_flags_from_decl (field_decl)), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))), + GET_TYPE_NAME (type), IDENTIFIER_POINTER (DECL_NAME (field_decl)), IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)))); return 1; } + check_deprecation (qual_wfl, field_decl); /* There are things to check when fields are accessed from type. There are no restrictions on a static @@ -7703,11 +9123,12 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) } from_cast = from_super = 0; - /* If we need to generate something to get a proper handle - on what this field is accessed from, do it now. */ + /* If we need to generate something to get a proper + handle on what this field is accessed from, do it + now. */ if (!is_static) { - decl = maybe_access_field (decl, *where_found, type); + decl = maybe_access_field (decl, *where_found, *type_found); if (decl == error_mark_node) return 1; } @@ -7721,7 +9142,6 @@ resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) search from */ decl = field_decl; } - from_type = 0; type = QUAL_DECL_TYPE (decl); } @@ -7752,32 +9172,19 @@ int not_accessible_p (reference, member, from_super) if (class_in_current_package (DECL_CONTEXT (member))) return 0; - if (TREE_CODE (member) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (member)) - { - /* Access from SUPER is granted */ - if (from_super) - return 0; - /* Otherwise, access isn't granted */ - return 1; - } - else - { - /* If accessed with the form `super.member', then access is - granted */ - if (from_super) - return 0; + /* If accessed with the form `super.member', then access is granted */ + if (from_super) + return 0; - /* Otherwise, access is granted if occuring from the class where - member is declared or a subclass of it */ - if (inherits_from_p (reference, current_class)) - return 0; - } + /* Otherwise, access is granted if occuring from the class where + member is declared or a subclass of it */ + if (inherits_from_p (reference, current_class)) + return 0; return 1; } /* Check access on private members. Access is granted only if it - occurs from within the class in witch it is declared*/ - + occurs from within the class in witch it is declared */ if (access_flag & ACC_PRIVATE) return (current_class == DECL_CONTEXT (member) ? 0 : 1); @@ -7791,6 +9198,40 @@ int not_accessible_p (reference, member, from_super) return 0; } +/* Test deprecated decl access. */ +static void +check_deprecation (wfl, decl) + tree wfl, decl; +{ + char *file = DECL_SOURCE_FILE (decl); + /* Complain if the field is deprecated and the file it was defined + in isn't compiled at the same time the file which contains its + use is */ + if (DECL_DEPRECATED (decl) + && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file))) + { + char the [20]; + switch (TREE_CODE (decl)) + { + case FUNCTION_DECL: + strcpy (the, "method"); + break; + case FIELD_DECL: + strcpy (the, "field"); + break; + case TYPE_DECL: + strcpy (the, "class"); + break; + default: + fatal ("unexpected DECL code - check_deprecation"); + } + parse_warning_context + (wfl, "The %s `%s' in class `%s' has been deprecated", + the, lang_printable_name (decl, 0), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))); + } +} + /* Returns 1 if class was declared in the current package, 0 otherwise */ static int @@ -7810,7 +9251,7 @@ class_in_current_package (class) qualified, class isn't in the current package. If there is a current package and the name of the CLASS is not qualified, class isn't in the current package */ - if (!ctxp->package && qualified_flag || ctxp->package && !qualified_flag) + if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag)) return 0; /* If there is not package and the name of CLASS isn't qualified, @@ -7835,28 +9276,31 @@ static tree maybe_access_field (decl, where, type) tree decl, where, type; { - if (DECL_P (decl) && decl != current_this - && (!(TREE_CODE (decl) != PARM_DECL - && FIELD_STATIC (decl))) - && !IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl))) + if (TREE_CODE (decl) == FIELD_DECL && decl != current_this + && !FIELD_STATIC (decl)) decl = build_field_ref (where ? where : current_this, - type, DECL_NAME (decl)); + (type ? type : DECL_CONTEXT (decl)), + DECL_NAME (decl)); return decl; } -/* Build a method invocation statement, by patching PATCH. If non NULL +/* Build a method invocation, by patching PATCH. If non NULL and according to the situation, PRIMARY and WHERE may be used. IS_STATIC is set to 1 if the invoked function is static. */ static tree -patch_method_invocation_stmt (patch, primary, where, is_static) +patch_method_invocation (patch, primary, where, is_static, ret_decl) tree patch, primary, where; int *is_static; + tree *ret_decl; { tree wfl = TREE_OPERAND (patch, 0); tree args = TREE_OPERAND (patch, 1); tree name = EXPR_WFL_NODE (wfl); - tree list, class_type; + tree list; + int is_static_flag = 0; + int is_super_init = 0; + tree this_arg = NULL_TREE; /* Should be overriden if everything goes well. Otherwise, if something fails, it should keep this value. It stop the @@ -7893,7 +9337,7 @@ patch_method_invocation_stmt (patch, primary, where, is_static) parse_error_context (wfl, "Can't search method `%s' in package " "`%s'",IDENTIFIER_POINTER (identifier), IDENTIFIER_POINTER (remainder)); - return error_mark_node; + PATCH_METHOD_RETURN_ERROR (); } /* We're resolving a call from a type */ else if (RESOLVE_TYPE_NAME_P (wfl)) @@ -7909,7 +9353,7 @@ patch_method_invocation_stmt (patch, primary, where, is_static) (identifier_wfl, "Can't make static reference to method " "`%s' in interface `%s'", IDENTIFIER_POINTER (identifier), IDENTIFIER_POINTER (name)); - return error_mark_node; + PATCH_METHOD_RETURN_ERROR (); } /* Look the method up in the type selector. The method ought to be static. */ @@ -7917,15 +9361,16 @@ patch_method_invocation_stmt (patch, primary, where, is_static) list = lookup_method_invoke (0, wfl, type, identifier, args); if (list && !METHOD_STATIC (list)) { - char *fct_name = strdup ((char *)lang_printable_name (list)); + char *fct_name = strdup (lang_printable_name (list, 0)); parse_error_context (identifier_wfl, "Can't make static reference to method `%s %s' in class `%s'", - lang_printable_name (TREE_TYPE (TREE_TYPE (list))), fct_name, - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); + lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0), + fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); free (fct_name); - return error_mark_node; + PATCH_METHOD_RETURN_ERROR (); } + args = nreverse (args); } /* We're resolving an expression name */ else @@ -7935,25 +9380,29 @@ patch_method_invocation_stmt (patch, primary, where, is_static) /* 1- Find the field to which the call applies */ field = resolve_field_access (wfl, NULL, &type); if (field == error_mark_node) - return error_mark_node; + PATCH_METHOD_RETURN_ERROR (); + /* field is used in lieu of a primary. It alows us not to + report errors on erroneous use of `this' in + constructors. */ + primary = field; /* 2- Do the layout of the class where the last field was found, so we can search it. */ - class_decl = - resolve_and_layout (DECL_NAME (TYPE_NAME (type)), NULL_TREE); - + class_decl = resolve_and_layout (type, NULL_TREE); + if (class_decl != NULL_TREE) + type = TREE_TYPE (class_decl); + /* 3- Retrieve a filtered list of method matches, Refine if necessary. In any cases, point out errors. */ list = lookup_method_invoke (0, identifier_wfl, type, identifier, args); /* 4- Add the field as an argument */ - args = tree_cons (NULL_TREE, field, args); + args = nreverse (args); + this_arg = field; } - /* CLASS_TYPE is used during the call to not_accessible_p and - IDENTIFIER_WFL will be used to report any problem further */ - class_type = TREE_TYPE (class_decl); + /* IDENTIFIER_WFL will be used to report any problem further */ wfl = identifier_wfl; } /* Resolution of simple names, names generated after a primary: or @@ -7966,24 +9415,54 @@ patch_method_invocation_stmt (patch, primary, where, is_static) /* We search constructor in their target class */ if (CALL_CONSTRUCTOR_P (patch)) { - class_to_search = resolve_no_layout (EXPR_WFL_NODE (wfl), NULL_TREE); - if (!class_to_search) + if (TREE_CODE (patch) == NEW_CLASS_EXPR) + class_to_search = EXPR_WFL_NODE (wfl); + else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) == + this_identifier_node) + class_to_search = NULL_TREE; + else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) == + super_identifier_node) { - parse_error_context - (wfl, "Class `%s' not found in type declaration", - IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl))); - return error_mark_node; + is_super_init = 1; + if (CLASSTYPE_SUPER (current_class)) + class_to_search = + DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class))); + else + { + parse_error_context (wfl, "Can't invoke super constructor " + "on java.lang.Object"); + PATCH_METHOD_RETURN_ERROR (); + } } - - /* Can't instantiate an abstract class */ - if (CLASS_ABSTRACT (class_to_search)) + + /* Class to search is NULL if we're searching the current one */ + if (class_to_search) { - parse_error_context - (wfl, "Class `%s' is an abstract class. It can't be " - "instantiated", IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl))); - return error_mark_node; + class_to_search = resolve_and_layout (class_to_search, + NULL_TREE); + if (!class_to_search) + { + parse_error_context + (wfl, "Class `%s' not found in type declaration", + IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl))); + PATCH_METHOD_RETURN_ERROR (); + } + + /* Can't instantiate an abstract class, but we can + invoke it's constructor. It's use within the `new' + context is denied here. */ + if (CLASS_ABSTRACT (class_to_search) + && TREE_CODE (patch) == NEW_CLASS_EXPR) + { + parse_error_context + (wfl, "Class `%s' is an abstract class. It can't be " + "instantiated", IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl))); + PATCH_METHOD_RETURN_ERROR (); + } + class_to_search = TREE_TYPE (class_to_search); } - class_to_search = TREE_TYPE (class_to_search); + else + class_to_search = current_class; lc = 1; } /* This is a regular search in the local class, unless an @@ -7997,49 +9476,90 @@ patch_method_invocation_stmt (patch, primary, where, is_static) /* NAME is a simple identifier or comes from a primary. Search in the class whose declaration contain the method being invoked. */ + resolve_and_layout (class_to_search, NULL_TREE); list = lookup_method_invoke (lc, wfl, class_to_search, name, args); /* Don't continue if no method were found, as the next statement can't be executed then. */ - if (!list) return error_mark_node; + if (!list) + PATCH_METHOD_RETURN_ERROR (); /* Check for static reference if non static methods */ if (check_for_static_method_reference (wfl, patch, list, class_to_search, primary)) - return error_mark_node; - - /* Non static/constructor methods are called with the current - object extra argument. If method is resolved as a primary, - use the primary otherwise use the current THIS. */ - if (!CALL_CONSTRUCTOR_P (patch) && !METHOD_STATIC (list)) - args = tree_cons (NULL_TREE, primary ? primary : current_this, args); + PATCH_METHOD_RETURN_ERROR (); - class_type = class_to_search; + /* Non static methods are called with the current object extra + argument. If patch a `new TYPE()', the argument is the value + returned by the object allocator. If method is resolved as a + primary, use the primary otherwise use the current THIS. */ + args = nreverse (args); + if (TREE_CODE (patch) != NEW_CLASS_EXPR) + this_arg = primary ? primary : current_this; } - + /* Merge point of all resolution schemes. If we have nothing, this is an error, already signaled */ - if (!list) return error_mark_node; - + if (!list) + PATCH_METHOD_RETURN_ERROR (); + /* Check accessibility, position the is_static flag, build and return the call */ - if (not_accessible_p (class_type, list, 0)) + if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0)) { - char *fct_name = strdup ((char *)lang_printable_name (list)); + char *fct_name = strdup (lang_printable_name (list, 0)); parse_error_context (wfl, "Can't access %s method `%s %s.%s' from `%s'", java_accstring_lookup (get_access_flags_from_decl (list)), - lang_printable_name (TREE_TYPE (TREE_TYPE (list))), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))), fct_name, - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)))); + lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))), + fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)))); free (fct_name); - return error_mark_node; + PATCH_METHOD_RETURN_ERROR (); + } + check_deprecation (wfl, list); + + is_static_flag = METHOD_STATIC (list); + if (! METHOD_STATIC (list) && this_arg != NULL_TREE) + args = tree_cons (NULL_TREE, this_arg, args); + + /* In the context of an explicit constructor invocation, we can't + invoke any method relying on `this'. Exceptions are: we're + invoking a static function, primary exists and is not the current + this, we're creating a new object. */ + if (ctxp->explicit_constructor_p + && !is_static_flag + && (!primary || primary == current_this) + && (TREE_CODE (patch) != NEW_CLASS_EXPR)) + { + parse_error_context + (wfl, "Can't reference `this' before the superclass constructor has " + "been called"); + PATCH_METHOD_RETURN_ERROR (); } - - if (is_static) - *is_static = METHOD_STATIC (list); java_parser_context_restore_global (); - return patch_invoke (patch, list, args, wfl); + if (is_static) + *is_static = is_static_flag; + /* Sometimes, we want the decl of the selected method. Such as for + EH checking */ + if (ret_decl) + *ret_decl = list; + patch = patch_invoke (patch, list, args); + if (is_super_init && CLASS_HAS_FINIT_P (current_class)) + { + /* Generate the code used to initialize fields declared with an + initialization statement. For now, it returns a call the the + artificial function $finit$, if required. */ + + tree finit_call = + build_method_invocation (build_expr_wfl (finit_identifier_node, + input_filename, 0, 0), + NULL_TREE); + patch = build (COMPOUND_EXPR, void_type_node, patch, + java_complete_tree (finit_call)); + CAN_COMPLETE_NORMALLY (patch) = 1; + } + return patch; } /* Check that we're not trying to do a static reference to a method in @@ -8052,10 +9572,10 @@ check_for_static_method_reference (wfl, node, method, where, primary) if (METHOD_STATIC (current_function_decl) && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node)) { - char *fct_name = strdup ((char *)lang_printable_name (method)); + char *fct_name = strdup (lang_printable_name (method, 0)); parse_error_context (wfl, "Can't make static reference to method `%s %s' in class `%s'", - lang_printable_name (TREE_TYPE (TREE_TYPE (method))), fct_name, + lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where)))); free (fct_name); return 1; @@ -8067,48 +9587,76 @@ check_for_static_method_reference (wfl, node, method, where, primary) mode. */ static tree -patch_invoke (patch, method, args, cl) +patch_invoke (patch, method, args) tree patch, method, args; - tree cl; { tree dtable, func; - tree signature = build_java_signature (TREE_TYPE (method)); - tree original_call; - - switch (invocation_mode (method, 0)) + tree original_call, t, ta; + + /* Last step for args: convert build-in types. If we're dealing with + a new TYPE() type call, the first argument to the constructor + isn't found in the incomming argument list, but delivered by + `new' */ + t = TYPE_ARG_TYPES (TREE_TYPE (method)); + if (TREE_CODE (patch) == NEW_CLASS_EXPR) + t = TREE_CHAIN (t); + for (ta = args; t != end_params_node && ta; + t = TREE_CHAIN (t), ta = TREE_CHAIN (ta)) + if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) && + TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t)) + TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta)); + + if (flag_emit_class_files) + func = method; + else { - case INVOKE_VIRTUAL: - dtable = invoke_build_dtable (0, args); - func = build_invokevirtual (dtable, method); - break; - case INVOKE_STATIC: - func = build_known_method_ref (method, TREE_TYPE (method), - DECL_CONTEXT (method), - signature, args); - args = nreverse (args); - break; + tree signature = build_java_signature (TREE_TYPE (method)); + switch (invocation_mode (method, CALL_USING_SUPER (patch))) + { + case INVOKE_VIRTUAL: + dtable = invoke_build_dtable (0, args); + func = build_invokevirtual (dtable, method); + break; - default: - fatal ("Unknown invocation mode - build_invoke"); - return NULL_TREE; - } + case INVOKE_SUPER: + case INVOKE_STATIC: + func = build_known_method_ref (method, TREE_TYPE (method), + DECL_CONTEXT (method), + signature, args); + break; + + case INVOKE_INTERFACE: + dtable = invoke_build_dtable (1, args); + func = build_invokeinterface (dtable, DECL_NAME (method), signature); + break; + default: + fatal ("internal error - unknown invocation_mode result"); + } + + /* Ensure self_type is initialized, (invokestatic). FIXME */ + func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func); + } - /* Ensure self_type is initialized, (invokestatic). FIXME */ - func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func); TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method)); TREE_OPERAND (patch, 0) = func; TREE_OPERAND (patch, 1) = args; original_call = patch; - /* We're calling a constructor. New is called an its returned value - is an argument to the constructor. We build a COMPOUND_EXPR and - use saved expression so that the overall NEW expression value is - a pointer to a newly created and initialized class. */ - if (CALL_CONSTRUCTOR_P (original_call)) + /* We're processing a `new TYPE ()' form. New is called an its + returned value is the first argument to the constructor. We build + a COMPOUND_EXPR and use saved expression so that the overall NEW + expression value is a pointer to a newly created and initialized + class. */ + if (TREE_CODE (original_call) == NEW_CLASS_EXPR) { tree class = DECL_CONTEXT (method); tree c1, saved_new, size, new; + if (flag_emit_class_files) + { + TREE_TYPE (patch) = build_pointer_type (class); + return patch; + } if (!TYPE_SIZE (class)) safe_layout_class (class); size = size_in_bytes (class); @@ -8135,25 +9683,26 @@ invocation_mode (method, super) { int access = get_access_flags_from_decl (method); - if (access & ACC_STATIC) + if (super) + return INVOKE_SUPER; + + if (access & ACC_STATIC || access & ACC_FINAL || access & ACC_PRIVATE) return INVOKE_STATIC; if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method)))) return INVOKE_STATIC; - if (super) - return INVOKE_SUPER; - if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method)))) return INVOKE_INTERFACE; if (DECL_CONSTRUCTOR_P (method)) return INVOKE_STATIC; - + return INVOKE_VIRTUAL; } -/* Retrieve a refined list of matching methods. */ +/* Retrieve a refined list of matching methods. It covers the step + 15.11.2 (Compile-Time Step 2) */ static tree lookup_method_invoke (lc, cl, class, name, arg_list) @@ -8161,159 +9710,271 @@ lookup_method_invoke (lc, cl, class, name, arg_list) tree cl; tree class, name, arg_list; { - tree method = make_node (FUNCTION_TYPE); - tree arg_type_list = NULL_TREE; - tree signature, list, node, scratch; + tree atl = end_params_node; /* Arg Type List */ + tree method, signature, list, node; + char *candidates; /* Used for error report */ + /* Fix the arguments */ for (node = arg_list; node; node = TREE_CHAIN (node)) { - tree current_arg; - current_arg = - build_tree_list (NULL_TREE, - promote_type (TREE_TYPE (TREE_VALUE (node)))); - arg_type_list = chainon (current_arg, arg_type_list); - } - TYPE_ARG_TYPES (method) = arg_type_list; + tree current_arg = TREE_TYPE (TREE_VALUE (node)); + /* Non primitive type may have to be resolved */ + if (!JPRIMITIVE_TYPE_P (current_arg)) + resolve_and_layout (current_arg, NULL_TREE); + /* And promoted */ + if (TREE_CODE (current_arg) == RECORD_TYPE) + current_arg = promote_type (current_arg); + atl = tree_cons (NULL_TREE, current_arg, atl); + } + + /* Find all candidates and then refine the list, searching for the + most specific method. */ + list = find_applicable_accessible_methods_list (lc, class, name, atl); + list = find_most_specific_methods_list (list); + if (list && !TREE_CHAIN (list)) + return TREE_VALUE (list); - if (!lc) + /* Issue an error. List candidates if any. Candidates are listed + only if accessible (non accessible methods may end-up here for + the sake of a better error report). */ + candidates = NULL; + if (list) { - signature = build_java_argument_signature (method); - list = match_java_method (class, name, signature); - list = refine_accessible_methods_list (lc, list); + tree current; + obstack_grow (&temporary_obstack, ". Candidates are:\n", 18); + for (current = list; current; current = TREE_CHAIN (current)) + { + tree cm = TREE_VALUE (current); + char string [4096]; + if (!cm || not_accessible_p (class, cm, 0)) + continue; + sprintf + (string, " `%s' in `%s'%s", + get_printable_method_name (cm), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))), + (TREE_CHAIN (current) ? "\n" : "")); + obstack_grow (&temporary_obstack, string, strlen (string)); + } + obstack_1grow (&temporary_obstack, '\0'); + candidates = obstack_finish (&temporary_obstack); + } + /* Issue the error message */ + method = make_node (FUNCTION_TYPE); + TYPE_ARG_TYPES (method) = atl; + signature = build_java_argument_signature (method); + parse_error_context (cl, "Can't find %s `%s(%s)' in class `%s'%s", + (lc ? "constructor" : "method"), + (lc ? + IDENTIFIER_POINTER(DECL_NAME (TYPE_NAME (class))) : + IDENTIFIER_POINTER (name)), + IDENTIFIER_POINTER (signature), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))), + (candidates ? candidates : "")); + return NULL_TREE; +} + +/* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1 + when we're looking for a constructor. */ + +static tree +find_applicable_accessible_methods_list (lc, class, name, arglist) + int lc; + tree class, name, arglist; +{ + tree list = NULL_TREE, all_list = NULL_TREE; + + /* Search interfaces */ + if (CLASS_INTERFACE (TYPE_NAME (class))) + { + static tree searched_interfaces = NULL_TREE; + static int search_not_done = 0; + int i, n; + tree basetype_vec = TYPE_BINFO_BASETYPES (class); + + /* Have we searched this interface already? */ + if (searched_interfaces) + { + tree current; + for (current = searched_interfaces; + current; current = TREE_CHAIN (current)) + if (TREE_VALUE (current) == class) + return NULL; + } + searched_interfaces = tree_cons (NULL_TREE, class, searched_interfaces); + + search_applicable_methods_list + (lc, TYPE_METHODS (class), name, arglist, &list, &all_list); + + n = TREE_VEC_LENGTH (basetype_vec); + for (i = 0; i < n; i++) + { + tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)); + tree rlist; + + /* Skip java.lang.Object (we'll search it once later.) */ + if (t == object_type_node) + continue; + + search_not_done++; + rlist = find_applicable_accessible_methods_list (lc, t, name, + arglist); + all_list = chainon (rlist, (list ? list : all_list)); + search_not_done--; + } + + /* We're done. Reset the searched interfaces list and finally search + java.lang.Object */ + if (!search_not_done) + { + searched_interfaces = NULL_TREE; + search_applicable_methods_list (lc, TYPE_METHODS (object_type_node), + name, arglist, &list, &all_list); + } } + /* Search classes */ else - { - TREE_TYPE (method) = void_type_node; - signature = build_java_signature (method); - list = lookup_java_constructor (class, signature); - } + while (class != NULL_TREE) + { + search_applicable_methods_list + (lc, TYPE_METHODS (class), name, arglist, &list, &all_list); + class = (lc ? NULL_TREE : CLASSTYPE_SUPER (class)); + } - if (!list) + /* Either return the list obtained or all selected (but + inaccessible) methods for better error report. */ + return (!list ? all_list : list); +} + +/* Effectively search for the approriate method in method */ + +static void +search_applicable_methods_list(lc, method, name, arglist, list, all_list) + int lc; + tree method, name, arglist; + tree *list, *all_list; +{ + for (; method; method = TREE_CHAIN (method)) { - parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'", - IDENTIFIER_POINTER (name), - IDENTIFIER_POINTER (signature), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))); - return NULL_TREE; + /* When dealing with constructor, stop here, otherwise search + other classes */ + if (lc && !DECL_CONSTRUCTOR_P (method)) + continue; + else if (!lc && (DECL_CONSTRUCTOR_P (method) + || (GET_METHOD_NAME (method) != name))) + continue; + + if (argument_types_convertible (method, arglist)) + { + /* Retain accessible methods only */ + if (!not_accessible_p (DECL_CONTEXT (current_function_decl), + method, 0)) + *list = tree_cons (NULL_TREE, method, *list); + else + /* Also retain all selected method here */ + *all_list = tree_cons (NULL_TREE, method, *list); + } } +} - if (lc) - return list; +/* 15.11.2.2 Choose the Most Specific Method */ - if (TREE_CHAIN (list)) +static tree +find_most_specific_methods_list (list) + tree list; +{ + int max = 0; + tree current, new_list = NULL_TREE; + for (current = list; current; current = TREE_CHAIN (current)) { - tree most_specific_list = NULL_TREE; - tree current; - /* 15.11.2.2 Choose the Most Specific Method */ - for (current = list; current; current = TREE_CHAIN (current)) + tree method; + DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0; + + for (method = list; method; method = TREE_CHAIN (method)) { - tree rest; - tree method = TREE_VALUE (list); - tree class_from = DECL_CONTEXT (method); - for (rest = TREE_CHAIN (current); rest; rest = TREE_CHAIN (rest)) + /* Don't test a method against itself */ + if (method == current) + continue; + + /* Compare arguments and location where method where declared */ + if (argument_types_convertible (TREE_VALUE (method), + TREE_VALUE (current)) + && valid_method_invocation_conversion_p + (DECL_CONTEXT (TREE_VALUE (method)), + DECL_CONTEXT (TREE_VALUE (current)))) { - tree other = TREE_VALUE (rest); - - /* METHOD can be declared more specific with regard to OTHER iif: - - - The class METHOD belongs can be converted to the - class OTHER belongs by method invocation conversion - (5.3). Since we're dealing with classes here, it is - covered by the identity conversion or the windening - primitive conversion. - - - The types of the arguments of METHOD can be - converted to the types of the arguments of OTHER by - method invocation conversion (5.3). */ - - if (valid_ref_assignconv_cast_p (class_from, - DECL_CONTEXT (other), 0) - && 1) /* Test on args non implemented */ - most_specific_list = tree_cons (NULL_TREE, method, - most_specific_list); + int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current)); + max = (v > max ? v : max); } } - list = most_specific_list; } - if (!list || TREE_CHAIN (list)) + /* Review the list and select the maximally specific methods */ + for (current = list; current; current = TREE_CHAIN (current)) + if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max) + new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list); + + /* If we can't find one, lower expectations and try to gather multiple + maximally specific methods */ + while (!new_list) { - parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'", - IDENTIFIER_POINTER (name), - IDENTIFIER_POINTER (signature), - IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))); - return NULL_TREE; + while (--max > 0) + { + if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max) + new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list); + } + return new_list; } - /* 15.11.3 Is the Chosen Method Appropriate ? */ - else - return TREE_VALUE (list); + return new_list; } -/* Refine accessible methods from the raw matching method list, as - specified in 15.11.4.3. Return a (possibly empty) new method - list. */ +/* Make sure that the type of each M2_OR_ARGLIST arguments can be + converted by method invocation conversion (5.3) to the type of the + corresponding parameter of M1. Implementation expects M2_OR_ARGLIST + to change less often than M1. */ -static tree -refine_accessible_methods_list (lc, list) - int lc; /* Looking for Constructor */ - tree list; +static int +argument_types_convertible (m1, m2_or_arglist) + tree m1, m2_or_arglist; { -#define ADD_TO_LIST_AND_CONTINUE \ - { \ - refined_list = tree_cons (NULL_TREE, method, refined_list); \ - continue; \ - } - tree node, refined_list = NULL_TREE; - tree current_class_name = DECL_NAME (TYPE_NAME (current_class)); - - for (node = list; node; node = TREE_CHAIN (node)) - { - int access, identical; - tree class_from, method, class_from_name; - - method = TREE_VALUE (node); + static tree m2_arg_value = NULL_TREE; + static tree m2_arg_cache = NULL_TREE; - /* Constructor not retained here, unless were specifically - looking for them. */ - if (lc && DECL_CONSTRUCTOR_P (method)) - ADD_TO_LIST_AND_CONTINUE; + register tree m1_arg, m2_arg; - access = get_access_flags_from_decl (method); - class_from = DECL_CONTEXT (method); - class_from_name = DECL_NAME (TYPE_NAME (class_from)); - - identical = identical_subpath_p (current_class_name, class_from_name); + m1_arg = TYPE_ARG_TYPES (TREE_TYPE (m1)); + if (!METHOD_STATIC (m1)) + m1_arg = TREE_CHAIN (m1_arg); - /* Check accessibility of class_from from the current one: This - test has been already carried out when qualify_ambiguous_name - tried to resolve a type found in an other package. It is not - necessary to retest things here, the error has been already - reported. */ - - /* Public method are always OK */ - if (access & ACC_PUBLIC) - ADD_TO_LIST_AND_CONTINUE; - - /* Protected method access is OK if classes are from the - same package or part of the same inheritance lineage */ - if ((access & ACC_PROTECTED) - && (inherits_from_p (current_class, class_from) || identical)) - ADD_TO_LIST_AND_CONTINUE; + if (m2_arg_value == m2_or_arglist) + m2_arg = m2_arg_cache; + else + { + /* M2_OR_ARGLIST can be a function DECL or a raw list of + argument types */ + if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL) + { + m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist)); + if (!METHOD_STATIC (m2_or_arglist)) + m2_arg = TREE_CHAIN (m2_arg); + } + else + m2_arg = m2_or_arglist; - /* Methods with default (package) access are OK if classes are - from the same default package. */ - if (identical || - (!QUALIFIED_P (class_from_name) && !QUALIFIED_P (current_class_name))) - ADD_TO_LIST_AND_CONTINUE; + m2_arg_value = m2_or_arglist; + m2_arg_cache = m2_arg; + } - /* Private method accessible iff current class is the node where - the method is defined */ - if ((access & ACC_PRIVATE) && (class_from == current_class)) - ADD_TO_LIST_AND_CONTINUE; + while (m1_arg != end_params_node && m2_arg != end_params_node) + { + resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE); + if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg), + TREE_VALUE (m2_arg))) + break; + m1_arg = TREE_CHAIN (m1_arg); + m2_arg = TREE_CHAIN (m2_arg); } -#undef ADD_TO_LIST_AND_CONTINUE - return refined_list; + return m1_arg == end_params_node && m2_arg == end_params_node; } /* Qualification routines */ @@ -8323,7 +9984,7 @@ qualify_ambiguous_name (id) tree id; { tree qual, qual_wfl, name, decl, ptr_type, saved_current_class; - int again, super_found = 0, this_found = 0; + int again, super_found = 0, this_found = 0, new_array_found = 0; /* We first qualify the first element, then derive qualification of others based on the first one. If the first element is qualified @@ -8351,11 +10012,21 @@ qualify_ambiguous_name (id) qual_wfl = QUAL_WFL (qual); } break; - case JAVA_NEW_CLASS_EXPR: + case NEW_ARRAY_EXPR: + qual = TREE_CHAIN (qual); + new_array_found = again = 1; + continue; + case NEW_CLASS_EXPR: case CONVERT_EXPR: - case ARRAY_REF: qual_wfl = TREE_OPERAND (qual_wfl, 0); break; + case ARRAY_REF: + while (TREE_CODE (qual_wfl) == ARRAY_REF) + qual_wfl = TREE_OPERAND (qual_wfl, 0); + break; + default: + /* Fix for -Wall. Just break doing nothing */ + break; } name = EXPR_WFL_NODE (qual_wfl); ptr_type = current_class; @@ -8365,7 +10036,10 @@ qualify_ambiguous_name (id) { qual = TREE_CHAIN (qual); qual_wfl = QUAL_WFL (qual); - name = EXPR_WFL_NODE (qual_wfl); + if (TREE_CODE (qual_wfl) == CALL_EXPR) + again = 1; + else + name = EXPR_WFL_NODE (qual_wfl); this_found = 1; } /* If we have a SUPER, we set the context accordingly */ @@ -8384,13 +10058,22 @@ qualify_ambiguous_name (id) /* Do one more interation to set things up */ super_found = again = 1; } + /* Loop one more time if we're dealing with ?: or a string + constant, or a convert expression */ + if (TREE_CODE (qual_wfl) == CONDITIONAL_EXPR + || TREE_CODE (qual_wfl) == STRING_CST + || TREE_CODE (qual_wfl) == CONVERT_EXPR) + { + qual = TREE_CHAIN (qual); + qual_wfl = QUAL_WFL (qual); + again = 1; + } } while (again); /* If name appears within the scope of a location variable declaration or parameter declaration, then it is an expression name. We don't carry this test out if we're in the context of the use of SUPER or THIS */ - if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name))) { RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1; @@ -8399,11 +10082,13 @@ qualify_ambiguous_name (id) /* If within the class/interface NAME was found to be used there exists a (possibly inherited) field named NAME, then this is an - expression name. */ - else if ((decl = lookup_field_wrapper (ptr_type, name))) + expression name. If we saw a NEW_ARRAY_EXPR before and want to + address length, it is OK. */ + else if ((decl = lookup_field_wrapper (ptr_type, name)) + || (new_array_found && name == length_identifier_node)) { RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1; - QUAL_RESOLUTION (qual) = decl; + QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl); } /* We reclassify NAME as a type name if: @@ -8421,7 +10106,8 @@ qualify_ambiguous_name (id) } /* Method call are expression name */ - else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR) + else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR + || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF) RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1; /* Check here that NAME isn't declared by more than one @@ -8482,49 +10168,57 @@ breakdown_qualified (left, right, source) return 0; } -/* Return 1 if N1 and N2 have identical sub-path. */ +/* Patch tree nodes in a function body. When a BLOCK is found, push + local variable decls if present. + Same as java_complete_lhs, but does resolve static finals to values. */ -static int -identical_subpath_p (n1, n2) - tree n1, n2; +static tree +java_complete_tree (node) + tree node; { - tree left1, left2; - - if (!QUALIFIED_P (n1) || !QUALIFIED_P (n2)) - return n1 == n2; - - breakdown_qualified (&left1, NULL, n1); - breakdown_qualified (&left2, NULL, n2); - - return left1 == left2; + node = java_complete_lhs (node); + if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node) + && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE) + { + tree value = DECL_INITIAL (node); + DECL_INITIAL (node) = NULL_TREE; + value = fold_constant_for_init (value, node); + DECL_INITIAL (node) = value; + if (value != NULL_TREE) + return value; + } + return node; } -static int -not_initialized_as_it_should_p (decl) - tree decl; +static tree +java_stabilize_reference (node) + tree node; { - if (DECL_P (decl)) + if (TREE_CODE (node) == COMPOUND_EXPR) { - if (TREE_CODE (decl) == FIELD_DECL - && METHOD_STATIC (current_function_decl)) - return 0; - return DECL_P (decl) && !INITIALIZED_P (decl); + tree op0 = TREE_OPERAND (node, 0); + tree op1 = TREE_OPERAND (node, 1); + TREE_OPERAND (node, 0) = save_expr (op0); + TREE_OPERAND (node, 1) = java_stabilize_reference (op1); + return node; } - return 0; + else + return stabilize_reference (node); } /* Patch tree nodes in a function body. When a BLOCK is found, push - local variable decls if present. */ + local variable decls if present. + Same as java_complete_tree, but does not resolve static finals to values. */ static tree -java_complete_tree (node) +java_complete_lhs (node) tree node; { - tree nn, cn, wfl_op1, wfl_op2; - int flag, location; + tree nn, cn, wfl_op1, wfl_op2, wfl_op3; + int flag; /* CONVERT_EXPR always has its type set, even though it needs to be - worked out */ + worked out. */ if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR) return node; @@ -8543,13 +10237,67 @@ java_complete_tree (node) { DECL_CONTEXT (cn) = current_function_decl; IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn; - INITIALIZED_P (cn) = 0; } - if (BLOCK_EXPR_BODY (node)) + if (BLOCK_EXPR_BODY (node) == NULL_TREE) + CAN_COMPLETE_NORMALLY (node) = 1; + else { - BLOCK_EXPR_BODY (node) = java_complete_tree (BLOCK_EXPR_BODY (node)); - if (BLOCK_EXPR_BODY (node) == error_mark_node) + tree stmt = BLOCK_EXPR_BODY (node); + tree *ptr; + int error_seen = 0; + if (TREE_CODE (stmt) == COMPOUND_EXPR) + { + /* Re-order from (((A; B); C); ...; Z) to + (A; (B; (C ; (...; Z)))). + This makes it easier to scan the statements left-to-right + without using recursion (which might overflow the stack + if the block has many statements. */ + for (;;) + { + tree left = TREE_OPERAND (stmt, 0); + if (TREE_CODE (left) != COMPOUND_EXPR) + break; + TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1); + TREE_OPERAND (left, 1) = stmt; + stmt = left; + } + BLOCK_EXPR_BODY (node) = stmt; + } + + /* Now do the actual complete, without deep recursion for + long blocks. */ + ptr = &BLOCK_EXPR_BODY (node); + while (TREE_CODE (*ptr) == COMPOUND_EXPR + && TREE_OPERAND (*ptr, 1) != empty_stmt_node) + { + tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0)); + tree *next = &TREE_OPERAND (*ptr, 1); + TREE_OPERAND (*ptr, 0) = cur; + if (TREE_CODE (cur) == ERROR_MARK) + error_seen++; + else if (! CAN_COMPLETE_NORMALLY (cur)) + { + wfl_op2 = *next; + for (;;) + { + if (TREE_CODE (wfl_op2) == BLOCK) + wfl_op2 = BLOCK_EXPR_BODY (wfl_op2); + else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR) + wfl_op2 = TREE_OPERAND (wfl_op2, 0); + else + break; + } + if (TREE_CODE (wfl_op2) != CASE_EXPR + && TREE_CODE (wfl_op2) != DEFAULT_EXPR) + unreachable_stmt_error (*ptr); + } + ptr = next; + } + *ptr = java_complete_tree (*ptr); + + if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0) return error_mark_node; + CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr); } /* Turn local bindings to null */ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn)) @@ -8559,12 +10307,52 @@ java_complete_tree (node) break; /* 2- They are expressions but ultimately deal with statements */ + + case THROW_EXPR: + wfl_op1 = TREE_OPERAND (node, 0); + COMPLETE_CHECK_OP_0 (node); + /* CAN_COMPLETE_NORMALLY (node) = 0; */ + return patch_throw_statement (node, wfl_op1); + + case SYNCHRONIZED_EXPR: + wfl_op1 = TREE_OPERAND (node, 0); + return patch_synchronized_statement (node, wfl_op1); + + case TRY_EXPR: + return patch_try_statement (node); + + case TRY_FINALLY_EXPR: + COMPLETE_CHECK_OP_0 (node); + COMPLETE_CHECK_OP_1 (node); + CAN_COMPLETE_NORMALLY (node) + = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0)) + && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))); + TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0)); + return node; + + case CLEANUP_POINT_EXPR: + COMPLETE_CHECK_OP_0 (node); + TREE_TYPE (node) = void_type_node; + CAN_COMPLETE_NORMALLY (node) = + CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0)); + return node; + + case WITH_CLEANUP_EXPR: + COMPLETE_CHECK_OP_0 (node); + COMPLETE_CHECK_OP_2 (node); + CAN_COMPLETE_NORMALLY (node) = + CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0)); + TREE_TYPE (node) = void_type_node; + return node; + case LABELED_BLOCK_EXPR: PUSH_LABELED_BLOCK (node); if (LABELED_BLOCK_BODY (node)) COMPLETE_CHECK_OP_1 (node); TREE_TYPE (node) = void_type_node; POP_LABELED_BLOCK (); + if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node))) + CAN_COMPLETE_NORMALLY (node) = 1; return node; case EXIT_BLOCK_EXPR: @@ -8572,21 +10360,92 @@ java_complete_tree (node) the EXIT_BLOCK_EXPR which doesn't exist it Java */ return patch_bc_statement (node); + case CASE_EXPR: + cn = java_complete_tree (TREE_OPERAND (node, 0)); + if (cn == error_mark_node) + return cn; + + /* First, the case expression must be constant */ + cn = fold (cn); + + if (!TREE_CONSTANT (cn)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + parse_error_context (node, "Constant expression required"); + return error_mark_node; + } + + nn = ctxp->current_loop; + + /* It must be assignable to the type of the switch expression. */ + if (!try_builtin_assignconv (NULL_TREE, + TREE_TYPE (TREE_OPERAND (nn, 0)), cn)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + parse_error_context + (wfl_operator, + "Incompatible type for case. Can't convert `%s' to `int'", + lang_printable_name (TREE_TYPE (cn), 0)); + return error_mark_node; + } + + cn = fold (convert (int_type_node, cn)); + + /* Multiple instance of a case label bearing the same + value is checked during code generation. The case + expression is allright so far. */ + TREE_OPERAND (node, 0) = cn; + TREE_TYPE (node) = void_type_node; + CAN_COMPLETE_NORMALLY (node) = 1; + TREE_SIDE_EFFECTS (node) = 1; + break; + + case DEFAULT_EXPR: + nn = ctxp->current_loop; + /* Only one default label is allowed per switch statement */ + if (SWITCH_HAS_DEFAULT (nn)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + parse_error_context (wfl_operator, + "Duplicate case label: `default'"); + return error_mark_node; + } + else + SWITCH_HAS_DEFAULT (nn) = 1; + TREE_TYPE (node) = void_type_node; + TREE_SIDE_EFFECTS (node) = 1; + CAN_COMPLETE_NORMALLY (node) = 1; + break; + + case SWITCH_EXPR: case LOOP_EXPR: PUSH_LOOP (node); /* Check whether the loop was enclosed in a labeled statement. If not, create one, insert the loop in it and return the node */ nn = patch_loop_statement (node); + /* Anyways, walk the body of the loop */ - TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0)); + if (TREE_CODE (node) == LOOP_EXPR) + TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0)); + /* Switch statement: walk the switch expression and the cases */ + else + node = patch_switch_statement (node); + if (TREE_OPERAND (node, 0) == error_mark_node) - return error_mark_node; - TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node; - /* If we returned something different, that's because we - inserted a label. Pop the label too. */ - if (nn != node) - POP_LABELED_BLOCK (); + nn = error_mark_node; + else + { + TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node; + /* If we returned something different, that's because we + inserted a label. Pop the label too. */ + if (nn != node) + { + if (CAN_COMPLETE_NORMALLY (node)) + CAN_COMPLETE_NORMALLY (nn) = 1; + POP_LABELED_BLOCK (); + } + } POP_LOOP (); return nn; @@ -8609,27 +10468,71 @@ java_complete_tree (node) return patch_if_else_statement (node); break; + case CONDITIONAL_EXPR: + /* Condition */ + wfl_op1 = TREE_OPERAND (node, 0); + COMPLETE_CHECK_OP_0 (node); + wfl_op2 = TREE_OPERAND (node, 1); + COMPLETE_CHECK_OP_1 (node); + wfl_op3 = TREE_OPERAND (node, 2); + COMPLETE_CHECK_OP_2 (node); + return patch_conditional_expr (node, wfl_op1, wfl_op2); + /* 3- Expression section */ case COMPOUND_EXPR: - TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0)); - TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1)); - if (TREE_OPERAND (node, 1) == error_mark_node) - return error_mark_node; + wfl_op2 = TREE_OPERAND (node, 1); + TREE_OPERAND (node, 0) = nn = + java_complete_tree (TREE_OPERAND (node, 0)); + if (wfl_op2 == empty_stmt_node) + CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn); + else + { + if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK) + { + /* An unreachable condition in a do-while statement + is *not* (technically) an unreachable statement. */ + nn = wfl_op2; + if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION) + nn = EXPR_WFL_NODE (nn); + if (TREE_CODE (nn) != EXIT_EXPR) + { + SET_WFL_OPERATOR (wfl_operator, node, wfl_op2); + parse_error_context (wfl_operator, "Unreachable statement"); + } + } + TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1)); + if (TREE_OPERAND (node, 1) == error_mark_node) + return error_mark_node; + CAN_COMPLETE_NORMALLY (node) + = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)); + } TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1)); break; case RETURN_EXPR: + /* CAN_COMPLETE_NORMALLY (node) = 0; */ return patch_return (node); case EXPR_WITH_FILE_LOCATION: if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */ || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE) - return resolve_expression_name (node); + { + node = resolve_expression_name (node, NULL); + if (node == error_mark_node) + return node; + CAN_COMPLETE_NORMALLY (node) = 1; + } else { - EXPR_WFL_NODE (node) = java_complete_tree (EXPR_WFL_NODE (node)); - TREE_SIDE_EFFECTS (node) = 1; - if (EXPR_WFL_NODE (node) == error_mark_node) + tree body; + int save_lineno = lineno; + lineno = EXPR_WFL_LINENO (node); + body = java_complete_tree (EXPR_WFL_NODE (node)); + lineno = save_lineno; + EXPR_WFL_NODE (node) = body; + TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body); + CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body); + if (body == error_mark_node) { /* Its important for the evaluation of assignment that this mark on the TREE_TYPE is propagated. */ @@ -8638,10 +10541,11 @@ java_complete_tree (node) } else TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node)); + } break; - case JAVA_NEW_ARRAY_EXPR: + case NEW_ARRAY_EXPR: /* Patch all the dimensions */ flag = 0; for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn)) @@ -8655,7 +10559,7 @@ java_complete_tree (node) } else { - TREE_VALUE (cn) = save_expr (dim); + TREE_VALUE (cn) = dim; /* Setup the location of the current dimension, for later error report. */ TREE_PURPOSE (cn) = @@ -8665,57 +10569,96 @@ java_complete_tree (node) } /* They complete the array creation expression, if no errors were found. */ - return (flag ? error_mark_node : patch_newarray (node)); + CAN_COMPLETE_NORMALLY (node) = 1; + return (flag ? error_mark_node + : force_evaluation_order (patch_newarray (node))); - case JAVA_NEW_CLASS_EXPR: + case NEW_CLASS_EXPR: case CALL_EXPR: - /* Complete function's argument first */ + /* Complete function's argument(s) first */ if (complete_function_arguments (node)) return error_mark_node; else - return patch_method_invocation_stmt (node, NULL_TREE, NULL_TREE, NULL); + { + tree decl, wfl = TREE_OPERAND (node, 0); + int in_this = CALL_THIS_CONSTRUCTOR_P (node); + + node = patch_method_invocation (node, NULL_TREE, + NULL_TREE, 0, &decl); + if (node == error_mark_node) + return error_mark_node; + + check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl); + /* If we call this(...), register signature and positions */ + if (in_this) + DECL_CONSTRUCTOR_CALLS (current_function_decl) = + tree_cons (wfl, decl, + DECL_CONSTRUCTOR_CALLS (current_function_decl)); + CAN_COMPLETE_NORMALLY (node) = 1; + return force_evaluation_order (node); + } case MODIFY_EXPR: /* Save potential wfls */ wfl_op1 = TREE_OPERAND (node, 0); wfl_op2 = TREE_OPERAND (node, 1); - TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1); + TREE_OPERAND (node, 0) = java_complete_lhs (wfl_op1); if (TREE_OPERAND (node, 0) == error_mark_node) return error_mark_node; if (COMPOUND_ASSIGN_P (wfl_op2)) { - tree lvalue; - tree other = - java_complete_tree (TREE_OPERAND (wfl_op2, 0)); + tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0)); /* Hand stablize the lhs on both places */ - lvalue = stabilize_reference (other); TREE_OPERAND (node, 0) = lvalue; TREE_OPERAND (TREE_OPERAND (node, 1), 0) = lvalue; - } - /* There are cases where the type of RHS is fixed. In those - cases, if the evaluation of the RHS fails, we further the - evaluation of the assignment to detect more errors. */ - nn = java_complete_tree (TREE_OPERAND (node, 1)); - if (nn == error_mark_node) - { - /* It's hopeless, but we can further things on to discover - an error during the assignment. In any cases, the - assignment operation fails. */ - if (TREE_CODE (TREE_OPERAND (node, 1)) != EXPR_WITH_FILE_LOCATION - && TREE_TYPE (TREE_OPERAND (node, 1)) != error_mark_node) - patch_assignment (node, wfl_op1, wfl_op2); + /* Now complete the RHS. We write it back later on. */ + nn = java_complete_tree (TREE_OPERAND (node, 1)); - /* Now, we still mark the lhs as initialized */ - if (DECL_P (TREE_OPERAND (node, 0))) - INITIALIZED_P (TREE_OPERAND (node, 0)) = 1; + if ((cn = patch_string (nn))) + nn = cn; - return error_mark_node; + /* The last part of the rewrite for E1 op= E2 is to have + E1 = (T)(E1 op E2), with T being the type of E1. */ + nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2), + TREE_TYPE (lvalue), nn)); } + + /* If we're about to patch a NEW_ARRAY_INIT, we call a special + function to complete this RHS */ + else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT) + nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)), + TREE_OPERAND (node, 1)); + /* Otherwise we simply complete the RHS */ + else + nn = java_complete_tree (TREE_OPERAND (node, 1)); + + if (nn == error_mark_node) + return error_mark_node; + + /* Write back the RHS as we evaluated it. */ TREE_OPERAND (node, 1) = nn; - return patch_assignment (node, wfl_op1, wfl_op2); + + /* In case we're handling = with a String as a RHS, we need to + produce a String out of the RHS (it might still be a + STRING_CST or a StringBuffer at this stage */ + if ((nn = patch_string (TREE_OPERAND (node, 1)))) + TREE_OPERAND (node, 1) = nn; + node = patch_assignment (node, wfl_op1, wfl_op2); + CAN_COMPLETE_NORMALLY (node) = 1; + + /* Before returning the node, in the context of a static field + assignment in <clinit>, we may want to carray further + optimizations. (VAR_DECL means it's a static field. See + add_field. */ + if (DECL_NAME (current_function_decl) == clinit_identifier_node + && MODIFY_EXPR_FROM_INITIALIZATION_P (node) + && TREE_CODE (TREE_OPERAND (node, 0)) == VAR_DECL) + node = patch_initialized_static_field (node); + + return node; case MULT_EXPR: case PLUS_EXPR: @@ -8740,15 +10683,35 @@ java_complete_tree (node) knows how to handle those cases. */ wfl_op1 = TREE_OPERAND (node, 0); wfl_op2 = TREE_OPERAND (node, 1); - TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1); - if (TREE_OPERAND (node, 0) == error_mark_node) - return error_mark_node; - TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2); - if (TREE_OPERAND (node, 1) == error_mark_node) - return error_mark_node; - return patch_binop (node, wfl_op1, wfl_op2); - case JAVA_UNARY_PLUS_EXPR: + CAN_COMPLETE_NORMALLY (node) = 1; + /* Don't complete string nodes if dealing with the PLUS operand. */ + if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1)) + { + nn = java_complete_tree (wfl_op1); + if (nn == error_mark_node) + return error_mark_node; + if ((cn = patch_string (nn))) + nn = cn; + TREE_OPERAND (node, 0) = nn; + } + if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2)) + { + nn = java_complete_tree (wfl_op2); + if (nn == error_mark_node) + return error_mark_node; + if ((cn = patch_string (nn))) + nn = cn; + TREE_OPERAND (node, 1) = nn; + } + return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2)); + + case INSTANCEOF_EXPR: + wfl_op1 = TREE_OPERAND (node, 0); + COMPLETE_CHECK_OP_0 (node); + return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1)); + + case UNARY_PLUS_EXPR: case NEGATE_EXPR: case TRUTH_NOT_EXPR: case BIT_NOT_EXPR: @@ -8760,10 +10723,13 @@ java_complete_tree (node) /* There are cases were wfl_op1 is a WFL. patch_unaryop knows how to handle those cases. */ wfl_op1 = TREE_OPERAND (node, 0); + CAN_COMPLETE_NORMALLY (node) = 1; TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1); if (TREE_OPERAND (node, 0) == error_mark_node) return error_mark_node; - return patch_unaryop (node, wfl_op1); + node = patch_unaryop (node, wfl_op1); + CAN_COMPLETE_NORMALLY (node) = 1; + break; case ARRAY_REF: /* There are cases were wfl_op1 is a WFL. patch_array_ref knows @@ -8772,14 +10738,45 @@ java_complete_tree (node) TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1); if (TREE_OPERAND (node, 0) == error_mark_node) return error_mark_node; + if (!flag_emit_class_files) + TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0)); /* The same applies to wfl_op2 */ wfl_op2 = TREE_OPERAND (node, 1); TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2); if (TREE_OPERAND (node, 1) == error_mark_node) return error_mark_node; - return patch_array_ref (node, wfl_op1, wfl_op2); + if (!flag_emit_class_files) + TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1)); + return patch_array_ref (node); - case JAVA_THIS_EXPR: + case RECORD_TYPE: + return node;; + + case COMPONENT_REF: + /* The first step in the re-write of qualified name handling. FIXME. + So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */ + TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0)); + if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE) + { + tree name = TREE_OPERAND (node, 1); + tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name); + if (field == NULL_TREE) + { + error ("missing static field `%s'", IDENTIFIER_POINTER (name)); + return error_mark_node; + } + if (! FIELD_STATIC (field)) + { + error ("not a static field `%s'", IDENTIFIER_POINTER (name)); + return error_mark_node; + } + return field; + } + else + fatal ("unimplemented java_complete_tree for COMPONENT_REF"); + break; + + case THIS_EXPR: /* Can't use THIS in a static environment */ if (!current_this) { @@ -8789,18 +10786,24 @@ java_complete_tree (node) TREE_TYPE (node) = error_mark_node; return error_mark_node; } + if (ctxp->explicit_constructor_p) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + parse_error_context + (wfl_operator, "Can't reference `this' or `super' before the " + "superclass constructor has been called"); + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } return current_this; - case STRING_CST: - /* Build the internal string representation */ - push_obstacks (&permanent_obstack, &permanent_obstack); - node = get_identifier (TREE_STRING_POINTER (node)); - location = alloc_name_constant (CONSTANT_String, node); - node = build_ref_from_constant_pool (location); - TREE_TYPE (node) = promote_type (string_type_node); - return node; - default: + CAN_COMPLETE_NORMALLY (node) = 1; + /* Ok: may be we have a STRING_CST or a crafted `StringBuffer' + and it's time to turn it into the appropriate String object + */ + if ((node = patch_string (node))) + return node; fatal ("No case for tree code `%s' - java_complete_tree\n", tree_code_name [TREE_CODE (node)]); } @@ -8817,25 +10820,27 @@ complete_function_arguments (node) int flag = 0; tree cn; + ctxp->explicit_constructor_p += (CALL_THIS_CONSTRUCTOR_P (node) ? 1 : 0); for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn)) { - tree wfl = TREE_VALUE (cn), parm; + tree wfl = TREE_VALUE (cn), parm, temp; parm = java_complete_tree (wfl); if (parm == error_mark_node) { flag = 1; continue; } - if (TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE) - TREE_VALUE (cn) = convert (promote_type (TREE_TYPE (parm)), parm); - else - TREE_VALUE (cn) = save_expr (parm); - if (not_initialized_as_it_should_p (parm)) - { - ERROR_VARIABLE_NOT_INITIALIZED (wfl, EXPR_WFL_NODE (wfl)); - INITIALIZED_P (parm) = 1; - } + /* If have a string literal that we haven't transformed yet or a + crafted string buffer, as a result of use of the the String + `+' operator. Build `parm.toString()' and expand it. */ + if ((temp = patch_string (parm))) + parm = temp; + /* Inline PRIMTYPE.TYPE read access */ + parm = maybe_build_primttype_type_ref (parm, wfl); + + TREE_VALUE (cn) = parm; } + ctxp->explicit_constructor_p -= (CALL_THIS_CONSTRUCTOR_P (node) ? 1 : 0); return flag; } @@ -8863,28 +10868,39 @@ build_expr_block (body, decls) { tree node = make_node (BLOCK); BLOCK_EXPR_DECLS (node) = decls; - BLOCK_EXPR_BODY (body); + BLOCK_EXPR_BODY (node) = body; if (body) TREE_TYPE (node) = TREE_TYPE (body); TREE_SIDE_EFFECTS (node) = 1; return node; } -/* Create a new function block and link its supercontext to the - previous block. The current function DECL is used as supercontext - when enter_block is called for the first time for a given - function. The current function body (DECL_FUNCTION_BODY) is set to - the newly created block. */ - -static block_level = 0; +/* Create a new function block and link it approriately to current + function block chain */ static tree enter_block () { - tree b = build_expr_block (NULL_TREE, NULL_TREE); + return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE))); +} + +/* Link block B supercontext to the previous block. The current + function DECL is used as supercontext when enter_a_block is called + for the first time for a given function. The current function body + (DECL_FUNCTION_BODY) is set to be block B. */ + +static tree +enter_a_block (b) + tree b; +{ tree fndecl = current_function_decl; - if (!DECL_FUNCTION_BODY (fndecl)) + if (!fndecl) { + BLOCK_SUPERCONTEXT (b) = current_static_block; + current_static_block = b; + } + + else if (!DECL_FUNCTION_BODY (fndecl)) { BLOCK_SUPERCONTEXT (b) = fndecl; DECL_FUNCTION_BODY (fndecl) = b; @@ -8904,11 +10920,20 @@ enter_block () static tree exit_block () { - tree b = DECL_FUNCTION_BODY (current_function_decl); - - if (BLOCK_SUPERCONTEXT (b) != current_function_decl) - DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b); + tree b; + if (current_function_decl) + { + b = DECL_FUNCTION_BODY (current_function_decl); + if (BLOCK_SUPERCONTEXT (b) != current_function_decl) + DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b); + } + else + { + b = current_static_block; + if (BLOCK_SUPERCONTEXT (b)) + current_static_block = BLOCK_SUPERCONTEXT (b); + } return b; } @@ -8920,7 +10945,7 @@ static tree lookup_name_in_blocks (name) tree name; { - tree b = DECL_FUNCTION_BODY (current_function_decl); + tree b = GET_CURRENT_BLOCK (current_function_decl); while (b != current_function_decl) { @@ -8942,7 +10967,7 @@ lookup_name_in_blocks (name) static void maybe_absorb_scoping_blocks () { - while (BLOCK_EXPR_ORIGIN (DECL_FUNCTION_BODY (current_function_decl))) + while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl))) { tree b = exit_block (); java_method_add_stmt (current_function_decl, b); @@ -8955,7 +10980,39 @@ maybe_absorb_scoping_blocks () are building incomplete tree nodes and the patch_* functions that are completing them. */ -/* Build an incomplete CALL_EXPR node. Encapsulate it within a WFL */ +/* Build a super() constructor invocation. Returns empty_stmt_node if + we're currently dealing with the class java.lang.Object. */ + +static tree +build_super_invocation () +{ + if (current_class == object_type_node) + return empty_stmt_node; + else + { + tree super_wfl = build_wfl_node (super_identifier_node); + return build_method_invocation (super_wfl, NULL_TREE); + } +} + +/* Build a SUPER/THIS qualified method invocation. */ + +static tree +build_this_super_qualified_invocation (use_this, name, args, lloc, rloc) + int use_this; + tree name, args; + int lloc, rloc; + +{ + tree invok; + tree wfl = + build_wfl_node (use_this ? this_identifier_node : super_identifier_node); + EXPR_WFL_LINECOL (wfl) = lloc; + invok = build_method_invocation (name, args); + return make_qualified_primary (wfl, invok, rloc); +} + +/* Build an incomplete CALL_EXPR node. */ static tree build_method_invocation (name, args) @@ -8964,7 +11021,18 @@ build_method_invocation (name, args) { tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE); TREE_SIDE_EFFECTS (call) = 1; - /* Check on cases where NAME isn't a WFL. FIXME */ + EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name); + return call; +} + +/* Build an incomplete new xxx(...) node. */ + +static tree +build_new_invocation (name, args) + tree name, args; +{ + tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE); + TREE_SIDE_EFFECTS (call) = 1; EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name); return call; } @@ -8993,7 +11061,7 @@ build_assignment (op, op_location, lhs, rhs) /* Print an INTEGER_CST node in a static buffer, and return the buffer. */ -static char * +char * print_int_node (node) tree node; { @@ -9018,6 +11086,48 @@ print_int_node (node) return buffer; } +/* Return 1 if you an assignment of a FINAL is attempted */ + +static int +check_final_assignment (lvalue, wfl) + tree lvalue, wfl; +{ + if (JDECL_P (lvalue) && FIELD_FINAL (lvalue) && + DECL_NAME (current_function_decl) != clinit_identifier_node) + { + parse_error_context + (wfl, "Can't assign a value to the final variable `%s'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl))); + return 1; + } + return 0; +} + +/* Inline references to java.lang.PRIMTYPE.TYPE when accessed in + read. This is needed to avoid circularities in the implementation + of these fields in libjava. */ + +static tree +maybe_build_primttype_type_ref (rhs, wfl) + tree rhs, wfl; +{ + tree to_return = NULL_TREE; + tree rhs_type = TREE_TYPE (rhs); + if (TREE_CODE (rhs) == COMPOUND_EXPR) + { + tree n = TREE_OPERAND (rhs, 1); + if (TREE_CODE (n) == VAR_DECL + && DECL_NAME (n) == TYPE_identifier_node + && rhs_type == class_ptr_type) + { + char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)); + if (!strncmp (self_name, "java.lang.", 10)) + to_return = build_primtype_type_ref (self_name); + } + } + return (to_return ? to_return : rhs ); +} + /* 15.25 Assignment operators. */ static tree @@ -9027,27 +11137,20 @@ patch_assignment (node, wfl_op1, wfl_op2) tree wfl_op2; { tree rhs = TREE_OPERAND (node, 1); - tree lvalue = TREE_OPERAND (node, 0); + tree lvalue = TREE_OPERAND (node, 0), llvalue; tree lhs_type, rhs_type, new_rhs = NULL_TREE; - int all_primitive; int error_found = 0; int lvalue_from_array = 0; /* Can't assign to a final. */ - if (DECL_P (lvalue) && FIELD_FINAL (lvalue)) - { - parse_error_context - (wfl_op1, "Can't assign a value to the final variable `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op1))); - error_found = 1; - } + if (check_final_assignment (lvalue, wfl_op1)) + error_found = 1; EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); /* Lhs can be a named variable */ - if (DECL_P (lvalue)) + if (JDECL_P (lvalue)) { - INITIALIZED_P (lvalue) = 1; lhs_type = TREE_TYPE (lvalue); } /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME + @@ -9063,64 +11166,30 @@ patch_assignment (node, wfl_op1, wfl_op2) /* Or a function return slot */ else if (TREE_CODE (lvalue) == RESULT_DECL) lhs_type = TREE_TYPE (lvalue); - /* Otherwise, this is an error */ - else + /* Otherwise, we might want to try to write into an optimized static + final, this is an of a different nature, reported further on. */ + else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION + && resolve_expression_name (wfl_op1, &llvalue) + && check_final_assignment (llvalue, wfl_op1)) + { + error_found = 1; + /* What we should do instead is resetting the all the flags + previously set, exchange lvalue for llvalue and continue. */ + return error_mark_node; + } + else { parse_error_context (wfl_op1, "Invalid left hand side of assignment"); error_found = 1; } rhs_type = TREE_TYPE (rhs); + /* 5.1 Try the assignment conversion for builtin type. */ + new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs); - /* 5.2 Begin Assignment conversion */ - - /* 5.1.1 Try Identity Conversion */ - if (lhs_type == rhs_type) - new_rhs = rhs; - - /* 5.1.2 Try Widening Primitive Conversion */ - all_primitive = JPRIMITIVE_TYPE_P (lhs_type) && JPRIMITIVE_TYPE_P (rhs_type); - if (all_primitive && JINTEGRAL_TYPE_P (rhs_type) - && ((TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)) - || (JFLOAT_TYPE_P (lhs_type) && - TYPE_PRECISION (rhs_type) == TYPE_PRECISION (lhs_type)))) - new_rhs = convert (lhs_type, rhs); - else if (all_primitive && JFLOAT_TYPE_P (rhs_type) - && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type))) - new_rhs = convert (lhs_type, rhs); - - /* Try a narrowing primitive conversion: - - expression is a constant expression of type int AND - - variable is byte, short or char AND - - The value of the expression is representable in the type of the - variable */ - else if (rhs_type == int_type_node && TREE_CONSTANT (rhs) - && (lhs_type == byte_type_node || lhs_type == char_type_node - || lhs_type == short_type_node)) - { - if (int_fits_type_p (rhs, lhs_type)) - new_rhs = convert (lhs_type, rhs); - else - parse_warning_context - (wfl_op1, "Constant expression `%s' to wide for narrowing " - "primitive conversion to `%s'", - print_int_node (rhs), lang_printable_name (lhs_type)); - /* Reported a warning that will turn into an error further - down, so we don't return */ - } - - /* 5.2 Try a reference conversion */ - else if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type)) - { - /* `null' may be assigned to any reference type */ - if (rhs == null_pointer_node) - new_rhs = null_pointer_node; - /* Try the reference assignment conversion */ - else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0)) - new_rhs = rhs; - if (new_rhs) - lhs_type = promote_type (rhs_type); - } + /* 5.2 If it failed, try a reference conversion */ + if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs))) + lhs_type = promote_type (rhs_type); /* 15.25.2 If we have a compound assignment, convert RHS into the type of the LHS */ @@ -9130,8 +11199,8 @@ patch_assignment (node, wfl_op1, wfl_op2) /* Explicit cast required. This is an error */ if (!new_rhs) { - char *t1 = strdup ((char *)lang_printable_name (TREE_TYPE (rhs))); - char *t2 = strdup ((char *)lang_printable_name (lhs_type)); + char *t1 = strdup (lang_printable_name (TREE_TYPE (rhs), 0)); + char *t2 = strdup (lang_printable_name (lhs_type, 0)); tree wfl; char operation [32]; /* Max size known */ @@ -9159,7 +11228,7 @@ patch_assignment (node, wfl_op1, wfl_op2) } parse_error_context - (wfl, (!can_cast_to_p (rhs_type, lhs_type) ? + (wfl, (!valid_cast_to_p (rhs_type, lhs_type) ? "Incompatible type for %s. Can't convert `%s' to `%s'" : "Incompatible type for %s. Explicit cast " "needed to convert `%s' to `%s'"), operation, t1, t2); @@ -9167,13 +11236,9 @@ patch_assignment (node, wfl_op1, wfl_op2) error_found = 1; } - /* Before reporting type incompatibility errors, check that the rhs - is initialized, if a variable */ - if (not_initialized_as_it_should_p (rhs)) - { - ERROR_VARIABLE_NOT_INITIALIZED (wfl_op2, DECL_NAME (rhs)); - INITIALIZED_P (rhs) = 1; - } + /* Inline read access to java.lang.PRIMTYPE.TYPE */ + if (new_rhs) + new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2); if (error_found) return error_mark_node; @@ -9182,32 +11247,155 @@ patch_assignment (node, wfl_op1, wfl_op2) assignment into an array element, return it here. */ if (TREE_CODE (node) == COMPOUND_EXPR) return node; - + TREE_OPERAND (node, 0) = lvalue; TREE_OPERAND (node, 1) = new_rhs; TREE_TYPE (node) = lhs_type; return node; } -/* Check that SOURCE can be converted into DEST, at least with a - cast. If the convertion can't occur at all, return 0 otherwise - 1. This function is used to produce accurate error messages on the - reasons why an assignment failed. */ +/* Optimize static (final) field initialized upon declaration. + - If the field is static final and is assigned to a primitive + constant type, then set its DECL_INITIAL to the value. + - More to come. */ + +static tree +patch_initialized_static_field (node) + tree node; +{ + tree field = TREE_OPERAND (node, 0); + tree value = TREE_OPERAND (node, 1); + + if (DECL_INITIAL (field) != NULL_TREE) + { + tree type = TREE_TYPE (value); + if (FIELD_FINAL (field) && TREE_CONSTANT (value) + && (JPRIMITIVE_TYPE_P (type) + || (flag_emit_class_files + && TREE_CODE (type) == POINTER_TYPE + && TREE_TYPE (type) == string_type_node))) + { + DECL_INITIAL (field) = value; + return empty_stmt_node; + } + DECL_INITIAL (field) = NULL_TREE; + } + return node; +} + +/* Check that type SOURCE can be cast into type DEST. If the cast + can't occur at all, return 0 otherwise 1. This function is used to + produce accurate error messages on the reasons why an assignment + failed. */ + +static tree +try_reference_assignconv (lhs_type, rhs) + tree lhs_type, rhs; +{ + tree new_rhs = NULL_TREE; + tree rhs_type = TREE_TYPE (rhs); + + if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type)) + { + /* `null' may be assigned to any reference type */ + if (rhs == null_pointer_node) + new_rhs = null_pointer_node; + /* Try the reference assignment conversion */ + else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0)) + new_rhs = rhs; + /* This is a magic assignment that we process differently */ + else if (rhs == soft_exceptioninfo_call_node) + new_rhs = rhs; + } + return new_rhs; +} + +/* Check that RHS can be converted into LHS_TYPE by the assignment + conversion (5.2), for the cases of RHS being a builtin type. Return + NULL_TREE if the conversion fails or if because RHS isn't of a + builtin type. Return a converted RHS if the conversion is possible. */ + +static tree +try_builtin_assignconv (wfl_op1, lhs_type, rhs) + tree wfl_op1, lhs_type, rhs; +{ + tree new_rhs = NULL_TREE; + tree rhs_type = TREE_TYPE (rhs); + + /* Zero accepted everywhere */ + if (TREE_CODE (rhs) == INTEGER_CST + && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0 + && JPRIMITIVE_TYPE_P (rhs_type)) + new_rhs = convert (lhs_type, rhs); + + /* 5.1.1 Try Identity Conversion, + 5.1.2 Try Widening Primitive Conversion */ + else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)) + new_rhs = convert (lhs_type, rhs); + + /* Try a narrowing primitive conversion (5.1.3): + - expression is a constant expression of type int AND + - variable is byte, short or char AND + - The value of the expression is representable in the type of the + variable */ + else if (rhs_type == int_type_node && TREE_CONSTANT (rhs) + && (lhs_type == byte_type_node || lhs_type == char_type_node + || lhs_type == short_type_node)) + { + if (int_fits_type_p (rhs, lhs_type)) + new_rhs = convert (lhs_type, rhs); + else if (wfl_op1) /* Might be called with a NULL */ + parse_warning_context + (wfl_op1, "Constant expression `%s' to wide for narrowing " + "primitive conversion to `%s'", + print_int_node (rhs), lang_printable_name (lhs_type, 0)); + /* Reported a warning that will turn into an error further + down, so we don't return */ + } + + return new_rhs; +} + +/* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity + conversion (5.1.1) or widening primitve conversion (5.1.2). Return + 0 is the conversion test fails. This implements parts the method + invocation convertion (5.3). */ static int -can_cast_to_p (source, dest) - tree source; - tree dest; +valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type) + tree lhs_type, rhs_type; { - if (TREE_CODE (source) == POINTER_TYPE) - source = TREE_TYPE (source); - if (TREE_CODE (dest) == POINTER_TYPE) - dest = TREE_TYPE (dest); + /* 5.1.1: This is the identity conversion part. */ + if (lhs_type == rhs_type) + return 1; - if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE) - return valid_ref_assignconv_cast_p (source, dest, 1); + /* Reject non primitive types */ + if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type)) + return 0; - else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest)) + /* 5.1.2: widening primitive conversion. byte, even if it's smaller + than a char can't be converted into a char. Short can't too, but + the < test below takes care of that */ + if (lhs_type == char_type_node && rhs_type == byte_type_node) + return 0; + + /* Accept all promoted type here. Note, we can't use <= in the test + below, because we still need to bounce out assignments of short + to char and the likes */ + if (lhs_type == int_type_node + && (rhs_type == promoted_byte_type_node + || rhs_type == promoted_short_type_node + || rhs_type == promoted_char_type_node + || rhs_type == promoted_boolean_type_node)) + return 1; + + /* From here, an integral is widened if its precision is smaller + than the precision of the LHS or if the LHS is a floating point + type, or the RHS is a float and the RHS a double. */ + if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type) + && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type))) + || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type)) + || (rhs_type == float_type_node && lhs_type == double_type_node)) return 1; return 0; @@ -9225,6 +11413,11 @@ valid_ref_assignconv_cast_p (source, dest, cast) tree dest; int cast; { + /* SOURCE or DEST might be null if not from a declared entity. */ + if (!source || !dest) + return 0; + if (JNULLP_TYPE_P (source)) + return 1; if (TREE_CODE (source) == POINTER_TYPE) source = TREE_TYPE (source); if (TREE_CODE (dest) == POINTER_TYPE) @@ -9234,7 +11427,7 @@ valid_ref_assignconv_cast_p (source, dest, cast) { if (TYPE_CLASS_P (dest)) return source == dest || inherits_from_p (source, dest) - || cast && inherits_from_p (dest, source); + || (cast && inherits_from_p (dest, source)); if (TYPE_INTERFACE_P (dest)) { /* If doing a cast and SOURCE is final, the operation is @@ -9257,7 +11450,7 @@ valid_ref_assignconv_cast_p (source, dest, cast) return dest == object_type_node; /* We're doing a cast. The cast is always valid is class DEST is not final, otherwise, DEST must implement SOURCE */ - else if (!CLASS_FINAL (TYPE_NAME (source))) + else if (!CLASS_FINAL (TYPE_NAME (dest))) return 1; else return interface_of_p (source, dest); @@ -9271,7 +11464,7 @@ valid_ref_assignconv_cast_p (source, dest, cast) { tree method_source, method_dest; tree source_type; - tree source_sig, dest_sig; + tree source_sig; tree source_name; for (method_source = TYPE_METHODS (source); method_source; method_source = TREE_CHAIN (method_source)) @@ -9300,13 +11493,18 @@ valid_ref_assignconv_cast_p (source, dest, cast) { if (TYPE_CLASS_P (dest)) return dest == object_type_node; + /* Can't cast an array to an interface unless the interface is + java.lang.Cloneable */ if (TYPE_INTERFACE_P (dest)) - return 0; /* Install test on Clonable. FIXME */ + return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0); else /* Arrays */ { tree source_element_type = TYPE_ARRAY_ELEMENT (source); tree dest_element_type = TYPE_ARRAY_ELEMENT (dest); + /* In case of severe errors, they turn out null */ + if (!dest_element_type || !source_element_type) + return 0; if (source_element_type == dest_element_type) return 1; return valid_ref_assignconv_cast_p (source_element_type, @@ -9317,6 +11515,53 @@ valid_ref_assignconv_cast_p (source, dest, cast) return 0; } +static int +valid_cast_to_p (source, dest) + tree source; + tree dest; +{ + if (TREE_CODE (source) == POINTER_TYPE) + source = TREE_TYPE (source); + if (TREE_CODE (dest) == POINTER_TYPE) + dest = TREE_TYPE (dest); + + if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE) + return valid_ref_assignconv_cast_p (source, dest, 1); + + else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest)) + return 1; + + return 0; +} + +/* Method invocation conversion test. Return 1 if type SOURCE can be + converted to type DEST through the methond invocation conversion + process (5.3) */ + +static tree +do_unary_numeric_promotion (arg) + tree arg; +{ + tree type = TREE_TYPE (arg); + if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32 + : TREE_CODE (type) == CHAR_TYPE) + arg = convert (int_type_node, arg); + return arg; +} + +/* Return a non zero value if SOURCE can be converted into DEST using + the method invocation conversion rule (5.3). */ +static int +valid_method_invocation_conversion_p (dest, source) + tree dest, source; +{ + return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest) + && valid_builtin_assignconv_identity_widening_p (dest, source)) + || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source)) + && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest)) + && valid_ref_assignconv_cast_p (source, dest, 0))); +} + /* Build an incomplete binop expression. */ static tree @@ -9325,15 +11570,7 @@ build_binop (op, op_location, op1, op2) int op_location; tree op1, op2; { - tree wfl; - - /* URSHIFT_EXPR is not part of what GCC understands, we can't directly build - a node with it */ - tree binop = - build ((op == URSHIFT_EXPR ? RSHIFT_EXPR : op), NULL_TREE, op1, op2); - if (op == URSHIFT_EXPR) - TREE_SET_CODE (binop, op); - + tree binop = build (op, NULL_TREE, op1, op2); TREE_SIDE_EFFECTS (binop) = 1; /* Store the location of the operator, for better error report. The string of the operator will be rebuild based on the OP value. */ @@ -9379,7 +11616,7 @@ operator_string (node) case GE_EXPR: BUILD_OPERATOR_STRING (">="); case LT_EXPR: BUILD_OPERATOR_STRING ("<"); case LE_EXPR: BUILD_OPERATOR_STRING ("<="); - case JAVA_UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+"); + case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+"); case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-"); case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!"); case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~"); @@ -9413,28 +11650,13 @@ patch_binop (node, wfl_op1, wfl_op2) tree op2_type = TREE_TYPE (op2); tree prom_type; int code = TREE_CODE (node); + /* If 1, tell the routine that we have to return error_mark_node after checking for the initialization of the RHS */ int error_found = 0; - /* Figure what is going to be checked first for initialization prior - its use. If NODE is part of a compound assignment, we check the - second operand first, otherwise the first one first. We also - initialize the matching WFL for the error report. `cfi' stands - for Check For Initialization */ - tree cfi = (COMPOUND_ASSIGN_P (node) ? op2 : op1); - tree cfi_wfl = (COMPOUND_ASSIGN_P (node) ? wfl_op2 : wfl_op1); - EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); - /* Check initialization of LHS first. We then silence further error - message if the variable wasn't initialized */ - if (not_initialized_as_it_should_p (cfi)) - { - ERROR_VARIABLE_NOT_INITIALIZED (cfi_wfl, DECL_NAME (cfi)); - INITIALIZED_P (op1) = 1; - } - switch (code) { /* 15.16 Multiplicative operators */ @@ -9455,16 +11677,36 @@ patch_binop (node, wfl_op1, wfl_op2) /* Change the division operator if necessary */ if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE) TREE_SET_CODE (node, TRUNC_DIV_EXPR); - /* This one is more complicated. FLOATs are processed by a function - call to soft_fmod. */ + + /* This one is more complicated. FLOATs are processed by a + function call to soft_fmod. Duplicate the value of the + COMPOUND_ASSIGN_P flag. */ if (code == TRUNC_MOD_EXPR) - return build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2); + { + tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2); + COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node); + TREE_SIDE_EFFECTS (mod) + = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2); + return mod; + } break; /* 15.17 Additive Operators */ case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */ - if (JSTRING_TYPE_P (op1_type) || JSTRING_TYPE_P (op2_type)) - fatal ("operator `+' non implemented on String - patch_binop"); + + /* Operation is valid if either one argument is a string + constant, a String object or a StringBuffer crafted for the + purpose of the a previous usage of the String concatenation + operator */ + + if (TREE_CODE (op1) == STRING_CST + || TREE_CODE (op2) == STRING_CST + || JSTRING_TYPE_P (op1_type) + || JSTRING_TYPE_P (op2_type) + || IS_CRAFTED_STRING_BUFFER_P (op1) + || IS_CRAFTED_STRING_BUFFER_P (op2)) + return build_string_concatenation (op1, op2); + case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for Numeric Types */ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type)) @@ -9495,7 +11737,7 @@ patch_binop (node, wfl_op1, wfl_op2) "shift distance from `%s' to integral" : "Incompatible type for `%s'. Can't convert shift distance from " "`%s' to integral"), - operator_string (node), lang_printable_name (op2_type)); + operator_string (node), lang_printable_name (op2_type, 0)); TREE_TYPE (node) = error_mark_node; error_found = 1; break; @@ -9503,8 +11745,8 @@ patch_binop (node, wfl_op1, wfl_op2) /* Unary numeric promotion (5.6.1) is performed on each operand separatly */ - op1 = convert (promote_type (op1_type), op1); - op2 = convert (promote_type (op2_type), op2); + op1 = do_unary_numeric_promotion (op1); + op2 = do_unary_numeric_promotion (op2); /* The type of the shift expression is the type of the promoted type of the left-hand operand */ @@ -9519,13 +11761,86 @@ patch_binop (node, wfl_op1, wfl_op2) build_int_2 (0x3f, 0))); /* The >>> operator is a >> operating on unsigned quantities */ - if (code == URSHIFT_EXPR) + if (code == URSHIFT_EXPR && ! flag_emit_class_files) { - op1 = convert (unsigned_type (prom_type), op1); + tree to_return; + tree utype = unsigned_type (prom_type); + op1 = convert (utype, op1); TREE_SET_CODE (node, RSHIFT_EXPR); + TREE_OPERAND (node, 0) = op1; + TREE_OPERAND (node, 1) = op2; + TREE_TYPE (node) = utype; + to_return = convert (prom_type, node); + /* Copy the original value of the COMPOUND_ASSIGN_P flag */ + COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node); + TREE_SIDE_EFFECTS (to_return) + = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2); + return to_return; } break; + + /* 15.19.1 Type Comparison Operator instaceof */ + case INSTANCEOF_EXPR: + + TREE_TYPE (node) = boolean_type_node; + + if (!(op2_type = resolve_type_during_patch (op2))) + return error_mark_node; + + /* The first operand must be a reference type or the null type */ + if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node) + error_found = 1; /* Error reported further below */ + + /* The second operand must be a reference type */ + if (!JREFERENCE_TYPE_P (op2_type)) + { + SET_WFL_OPERATOR (wfl_operator, node, wfl_op2); + parse_error_context + (wfl_operator, "Invalid argument `%s' for `instanceof'", + lang_printable_name (op2_type, 0)); + error_found = 1; + } + + if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1)) + { + /* If the first operand is null, the result is always false */ + if (op1 == null_pointer_node) + return boolean_false_node; + else if (flag_emit_class_files) + { + TREE_OPERAND (node, 1) = op2_type; + TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1); + return node; + } + /* Otherwise we have to invoke instance of to figure it out */ + else + { + tree call = + build (CALL_EXPR, boolean_type_node, + build_address_of (soft_instanceof_node), + tree_cons + (NULL_TREE, op1, + build_tree_list (NULL_TREE, + build_class_ref (op2_type))), + NULL_TREE); + TREE_SIDE_EFFECTS (call) = TREE_SIDE_EFFECTS (op1); + return call; + } + } + /* There is no way the expression operand can be an instance of + the type operand. This is a compile time error. */ + else + { + char *t1 = strdup (lang_printable_name (op1_type, 0)); + SET_WFL_OPERATOR (wfl_operator, node, wfl_op1); + parse_error_context + (wfl_operator, "Impossible for `%s' to be instance of `%s'", + t1, lang_printable_name (op2_type, 0)); + free (t1); + error_found = 1; + } + break; /* 15.21 Bitwise and Logical Operators */ case BIT_AND_EXPR: @@ -9601,7 +11916,7 @@ patch_binop (node, wfl_op1, wfl_op2) case NE_EXPR: /* 15.20.1 Numerical Equality Operators == and != */ /* Binary numeric promotion is performed on the operands */ - if (JPRIMITIVE_TYPE_P (op1_type) && JPRIMITIVE_TYPE_P (op2_type)) + if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type)) binary_numeric_promotion (op1_type, op2_type, &op1, &op2); /* 15.20.2 Boolean Equality Operators == and != */ @@ -9610,13 +11925,14 @@ patch_binop (node, wfl_op1, wfl_op2) ; /* Nothing to do here */ /* 15.20.3 Reference Equality Operators == and != */ - /* Types have to be either references or the null type */ - else if ((op1 == null_pointer_node || op2 == null_pointer_node - || JREFERENCE_TYPE_P (op1_type) - || JREFERENCE_TYPE_P (op2_type)) - && ((op1_type == op2_type) - /* The should use a can_cast_to_p() */ - )) + /* Types have to be either references or the null type. If + they're references, it must be possible to convert either + type to the other by casting conversion. */ + else if (op1 == null_pointer_node || op2 == null_pointer_node + || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type) + && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1) + || valid_ref_assignconv_cast_p (op2_type, + op1_type, 1)))) ; /* Nothing to do here */ /* Else we have an error figure what can't be converted into @@ -9624,11 +11940,11 @@ patch_binop (node, wfl_op1, wfl_op2) else { char *t1; - t1 = strdup ((char *)lang_printable_name (op1_type)); + t1 = strdup (lang_printable_name (op1_type, 0)); parse_error_context (wfl_operator, "Incompatible type for `%s'. Can't convert `%s' " "to `%s'", operator_string (node), t1, - lang_printable_name (op2_type)); + lang_printable_name (op2_type, 0)); free (t1); TREE_TYPE (node) = boolean_type_node; error_found = 1; @@ -9638,29 +11954,241 @@ patch_binop (node, wfl_op1, wfl_op2) break; } - /* Then check the initialization of the RHS. We don't do that if - we're dealing with a node that is part of a compound - assignment. We then silence further error message if the variable - wasn't initialized */ - if (not_initialized_as_it_should_p (op2) && !COMPOUND_ASSIGN_P (node)) - { - ERROR_VARIABLE_NOT_INITIALIZED (wfl_op2, DECL_NAME (op2)); - INITIALIZED_P (op2) = 1; - } - if (error_found) return error_mark_node; TREE_OPERAND (node, 0) = op1; TREE_OPERAND (node, 1) = op2; TREE_TYPE (node) = prom_type; - return fold (node); + TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2); + + /* fold does not respect side-effect order as required for Java but not C. */ + if (! TREE_SIDE_EFFECTS (node)) + node = fold (node); + return node; +} + +/* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non + zero value, the value of CSTE comes after the valude of STRING */ + +static tree +do_merge_string_cste (cste, string, string_len, after) + tree cste; + char *string; + int string_len, after; +{ + int len = TREE_STRING_LENGTH (cste) + string_len; + char *old = TREE_STRING_POINTER (cste); + TREE_STRING_LENGTH (cste) = len; + TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1); + if (after) + { + strcpy (TREE_STRING_POINTER (cste), string); + strcat (TREE_STRING_POINTER (cste), old); + } + else + { + strcpy (TREE_STRING_POINTER (cste), old); + strcat (TREE_STRING_POINTER (cste), string); + } + return cste; +} + +/* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a + new STRING_CST on success, NULL_TREE on failure */ + +static tree +merge_string_cste (op1, op2, after) + tree op1, op2; + int after; +{ + /* Handle two string constants right away */ + if (TREE_CODE (op2) == STRING_CST) + return do_merge_string_cste (op1, TREE_STRING_POINTER (op2), + TREE_STRING_LENGTH (op2), after); + + /* Reasonable integer constant can be treated right away */ + if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2)) + { + static char *boolean_true = "true"; + static char *boolean_false = "false"; + static char *null_pointer = "null"; + char ch[3]; + char *string; + + if (op2 == boolean_true_node) + string = boolean_true; + else if (op2 == boolean_false_node) + string = boolean_false; + else if (op2 == null_pointer_node) + string = null_pointer; + else if (TREE_TYPE (op2) == char_type_node) + { + ch[0] = (char )TREE_INT_CST_LOW (op2); + ch[1] = '\0'; + string = ch; + } + else + string = print_int_node (op2); + + return do_merge_string_cste (op1, string, strlen (string), after); + } + return NULL_TREE; +} + +/* Tries to statically concatenate OP1 and OP2 if possible. Either one + has to be a STRING_CST and the other part must be a STRING_CST or a + INTEGRAL constant. Return a new STRING_CST if the operation + succeed, NULL_TREE otherwise. + + If the case we want to optimize for space, we might want to return + NULL_TREE for each invocation of this routine. FIXME */ + +static tree +string_constant_concatenation (op1, op2) + tree op1, op2; +{ + if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST)) + { + tree string, rest; + int invert; + + string = (TREE_CODE (op1) == STRING_CST ? op1 : op2); + rest = (string == op1 ? op2 : op1); + invert = (string == op1 ? 0 : 1 ); + + /* Walk REST, only if it looks reasonable */ + if (TREE_CODE (rest) != STRING_CST + && !IS_CRAFTED_STRING_BUFFER_P (rest) + && !JSTRING_TYPE_P (TREE_TYPE (rest)) + && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION) + { + rest = java_complete_tree (rest); + if (rest == error_mark_node) + return error_mark_node; + rest = fold (rest); + } + return merge_string_cste (string, rest, invert); + } + return NULL_TREE; +} + +/* Implement the `+' operator. Does static optimization if possible, + otherwise create (if necessary) and append elements to a + StringBuffer. The StringBuffer will be carried around until it is + used for a function call or an assignment. Then toString() will be + called on it to turn it into a String object. */ + +static tree +build_string_concatenation (op1, op2) + tree op1, op2; +{ + tree result; + int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2); + + /* Try to do some static optimization */ + if ((result = string_constant_concatenation (op1, op2))) + return result; + + /* Discard empty strings on either side of the expression */ + if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0) + { + op1 = op2; + op2 = NULL_TREE; + } + else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0) + op2 = NULL_TREE; + + /* If operands are string constant, turn then into object references */ + if (TREE_CODE (op1) == STRING_CST) + op1 = patch_string_cst (op1); + if (op2 && TREE_CODE (op2) == STRING_CST) + op2 = patch_string_cst (op2); + + /* If either one of the constant is null and the other non null + operand is a String object, return it. */ + if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2) + return op1; + + /* If OP1 isn't already a StringBuffer, create and + initialize a new one */ + if (!IS_CRAFTED_STRING_BUFFER_P (op1)) + { + /* Two solutions here: + 1) OP1 is a string reference, we call new StringBuffer(OP1) + 2) OP1 is something else, we call new StringBuffer().append(OP1). */ + if (JSTRING_TYPE_P (TREE_TYPE (op1))) + op1 = BUILD_STRING_BUFFER (op1); + else + { + tree aNew = BUILD_STRING_BUFFER (NULL_TREE); + op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0); + } + } + + if (op2) + { + /* OP1 is no longer the last node holding a crafted StringBuffer */ + IS_CRAFTED_STRING_BUFFER_P (op1) = 0; + /* Create a node for `{new...,xxx}.append (op2)' */ + if (op2) + op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0); + } + + /* Mark the last node holding a crafted StringBuffer */ + IS_CRAFTED_STRING_BUFFER_P (op1) = 1; + + TREE_SIDE_EFFECTS (op1) = side_effects; + return op1; } -/* Build an incomplete unary operator expression. Unary `+' node is - build as a CONV_EXPR, even though its tree code is overridden by a - JAVA_UNARY_PLUS_EXPR that isn't a tree code, to differentiate it during - the walk. */ +/* Patch the string node NODE. NODE can be a STRING_CST of a crafted + StringBuffer. If no string were found to be patched, return + NULL. */ + +static tree +patch_string (node) + tree node; +{ + if (node == error_mark_node) + return error_mark_node; + if (TREE_CODE (node) == STRING_CST) + return patch_string_cst (node); + else if (IS_CRAFTED_STRING_BUFFER_P (node)) + { + int saved = ctxp->explicit_constructor_p; + tree invoke = build_method_invocation (wfl_to_string, NULL_TREE); + tree ret; + /* Temporary disable forbid the use of `this'. */ + ctxp->explicit_constructor_p = 0; + ret = java_complete_tree (make_qualified_primary (node, invoke, 0)); + /* Restore it at its previous value */ + ctxp->explicit_constructor_p = saved; + return ret; + } + return NULL_TREE; +} + +/* Build the internal representation of a string constant. */ + +static tree +patch_string_cst (node) + tree node; +{ + int location; + if (! flag_emit_class_files) + { + push_obstacks (&permanent_obstack, &permanent_obstack); + node = get_identifier (TREE_STRING_POINTER (node)); + location = alloc_name_constant (CONSTANT_String, node); + node = build_ref_from_constant_pool (location); + } + TREE_TYPE (node) = promote_type (string_type_node); + TREE_CONSTANT (node) = 1; + return node; +} + +/* Build an incomplete unary operator expression. */ static tree build_unaryop (op_token, op_location, op1) @@ -9671,7 +12199,7 @@ build_unaryop (op_token, op_location, op1) tree unaryop; switch (op_token) { - case PLUS_TK: op = CONVERT_EXPR; break; + case PLUS_TK: op = UNARY_PLUS_EXPR; break; case MINUS_TK: op = NEGATE_EXPR; break; case NEG_TK: op = TRUTH_NOT_EXPR; break; case NOT_TK: op = BIT_NOT_EXPR; break; @@ -9680,9 +12208,6 @@ build_unaryop (op_token, op_location, op1) } unaryop = build1 (op, NULL_TREE, op1); - if (op_token == PLUS_TK) - TREE_SET_CODE (unaryop, JAVA_UNARY_PLUS_EXPR); - TREE_SIDE_EFFECTS (unaryop) = 1; /* Store the location of the operator, for better error report. The string of the operator will be rebuild based on the OP value. */ @@ -9739,7 +12264,7 @@ patch_unaryop (node, wfl_op) { tree op = TREE_OPERAND (node, 0); tree op_type = TREE_TYPE (op); - tree prom_type, value; + tree prom_type, value, decl; int code = TREE_CODE (node); int error_found = 0; @@ -9755,21 +12280,27 @@ patch_unaryop (node, wfl_op) case PREINCREMENT_EXPR: /* 15.14.2 Prefix Decrement Operator -- */ case PREDECREMENT_EXPR: - if (!DECL_P (op)) - { - parse_error_context (wfl_operator, "Invalid argument to `%s'", - operator_string (node)); - TREE_TYPE (node) = error_mark_node; - error_found = 1; - } - else if (FIELD_FINAL (op)) + decl = strip_out_static_field_access_decl (op); + if (!JDECL_P (decl) + && !((TREE_CODE (decl) == INDIRECT_REF + || TREE_CODE (decl) == COMPONENT_REF) + && JPRIMITIVE_TYPE_P (TREE_TYPE (decl)))) { - parse_error_context - (wfl_op, "Can't assign a value to the final variable `%s'", - IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op))); + tree lvalue; + /* Before screaming, check that we're not in fact trying to + increment a optimized static final access, in which case + we issue an different error message. */ + if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION + && resolve_expression_name (wfl_op, &lvalue) + && check_final_assignment (lvalue, wfl_op))) + parse_error_context (wfl_operator, "Invalid argument to `%s'", + operator_string (node)); TREE_TYPE (node) = error_mark_node; error_found = 1; } + else if (check_final_assignment (op, wfl_op)) + error_found = 1; + /* From now on, we know that op if a variable and that it has a valid wfl. We use wfl_op to locate errors related to the ++/-- operand. */ @@ -9777,24 +12308,27 @@ patch_unaryop (node, wfl_op) { parse_error_context (wfl_op, "Invalid argument type `%s' to `%s'", - lang_printable_name (op_type), operator_string (node)); + lang_printable_name (op_type, 0), operator_string (node)); TREE_TYPE (node) = error_mark_node; error_found = 1; } else { - /* Before the addition, binary numeric promotion if performed on + /* Before the addition, binary numeric promotion is performed on both operands */ - value = integer_one_node; - prom_type = binary_numeric_promotion (op_type, TREE_TYPE (value), - &op, &value); - /* And write the promoted increment back */ + value = build_int_2 (1, 0); + TREE_TYPE (node) = + binary_numeric_promotion (op_type, TREE_TYPE (value), &op, &value); + /* And write the promoted incremented and increment */ + TREE_OPERAND (node, 0) = op; TREE_OPERAND (node, 1) = value; + /* Convert the overall back into its original type. */ + return fold (convert (op_type, node)); } break; /* 15.14.3 Unary Plus Operator + */ - case JAVA_UNARY_PLUS_EXPR: + case UNARY_PLUS_EXPR: /* 15.14.4 Unary Minus Operator - */ case NEGATE_EXPR: if (!JNUMERIC_TYPE_P (op_type)) @@ -9806,10 +12340,10 @@ patch_unaryop (node, wfl_op) /* Unary numeric promotion is performed on operand */ else { - prom_type = promote_type (op_type); - op = convert (prom_type, op); - if (code == JAVA_UNARY_PLUS_EXPR) - node = op; + op = do_unary_numeric_promotion (op); + prom_type = TREE_TYPE (op); + if (code == UNARY_PLUS_EXPR) + return fold (op); } break; @@ -9823,8 +12357,8 @@ patch_unaryop (node, wfl_op) } else { - prom_type = promote_type (op_type); - op = convert (prom_type, op); + op = do_unary_numeric_promotion (op); + prom_type = TREE_TYPE (op); } break; @@ -9833,6 +12367,8 @@ patch_unaryop (node, wfl_op) if (TREE_CODE (op_type) != BOOLEAN_TYPE) { ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type); + /* But the type is known. We will report an error if further + attempt of a assignment is made with this rhs */ TREE_TYPE (node) = boolean_type_node; error_found = 1; } @@ -9842,32 +12378,33 @@ patch_unaryop (node, wfl_op) /* 15.15 Cast Expression */ case CONVERT_EXPR: - value = patch_cast (node, wfl_op, wfl_operator); + value = patch_cast (node, wfl_operator); if (value == error_mark_node) { + /* If this cast is part of an assignment, we tell the code + that deals with it not to complain about a mismatch, + because things have been cast, anyways */ TREE_TYPE (node) = error_mark_node; error_found = 1; } else - node = value; + { + value = fold (value); + TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op); + return value; + } break; } - /* Check variable initialization */ - if (not_initialized_as_it_should_p (op)) - { - ERROR_VARIABLE_NOT_INITIALIZED (wfl_op, DECL_NAME (op)); - INITIALIZED_P (op) = 1; - } - if (error_found) return error_mark_node; - /* In the case of JAVA_UNARY_PLUS_EXPR, we replaced NODE by a new one */ - else if (code != JAVA_UNARY_PLUS_EXPR && code != CONVERT_EXPR) - { - TREE_OPERAND (node, 0) = op; - TREE_TYPE (node) = prom_type; - } + + /* There are cases where node has been replaced by something else + and we don't end up returning here: UNARY_PLUS_EXPR, + CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */ + TREE_OPERAND (node, 0) = fold (op); + TREE_TYPE (node) = prom_type; + TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op); return fold (node); } @@ -9890,7 +12427,10 @@ resolve_type_during_patch (type) return NULL_TREE; } else - return TREE_TYPE (type_decl); + { + CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1; + return TREE_TYPE (type_decl); + } } return type; } @@ -9898,9 +12438,8 @@ resolve_type_during_patch (type) found. Otherwise NODE or something meant to replace it is returned. */ static tree -patch_cast (node, wfl_op, wfl_operator) +patch_cast (node, wfl_operator) tree node; - tree wfl_op; tree wfl_operator; { tree op = TREE_OPERAND (node, 0); @@ -9920,12 +12459,25 @@ patch_cast (node, wfl_op, wfl_operator) if (cast_type == op_type) return node; + /* float and double type are converted to the original type main + variant and then to the target type. */ + if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE) + op = convert (integer_type_node, op); + /* Try widening/narowwing convertion. Potentially, things need to be worked out in gcc so we implement the extreme cases correctly. fold_convert() needs to be fixed. */ return convert (cast_type, op); } + /* It's also valid to cast a boolean into a boolean */ + if (op_type == boolean_type_node && cast_type == boolean_type_node) + return node; + + /* null can be casted to references */ + if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type)) + return build_null_of_type (cast_type); + /* The remaining legal casts involve conversion between reference types. Check for their compile time correctness. */ if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type) @@ -9937,7 +12489,16 @@ patch_cast (node, wfl_op, wfl_operator) conversion (5.2) */ if (valid_ref_assignconv_cast_p (op_type, cast_type, 0)) - return node; + { + TREE_SET_CODE (node, NOP_EXPR); + return node; + } + + if (flag_emit_class_files) + { + TREE_SET_CODE (node, CONVERT_EXPR); + return node; + } /* The cast requires a run-time check */ return build (CALL_EXPR, promote_type (cast_type), @@ -9948,13 +12509,24 @@ patch_cast (node, wfl_op, wfl_operator) } /* Any other casts are proven incorrect at compile time */ - t1 = strdup ((char *)lang_printable_name (op_type)); + t1 = strdup (lang_printable_name (op_type, 0)); parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'", - t1, lang_printable_name (cast_type)); + t1, lang_printable_name (cast_type, 0)); free (t1); return error_mark_node; } +/* Build a null constant and give it the type TYPE. */ + +static tree +build_null_of_type (type) + tree type; +{ + tree node = build_int_2 (0, 0); + TREE_TYPE (node) = promote_type (type); + return node; +} + /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't a list of indices. */ static tree @@ -9970,26 +12542,17 @@ build_array_ref (location, array, index) /* 15.12 Array Access Expression */ static tree -patch_array_ref (node, wfl_array, wfl_index) - tree node, wfl_array, wfl_index; +patch_array_ref (node) + tree node; { tree array = TREE_OPERAND (node, 0); tree array_type = TREE_TYPE (array); tree index = TREE_OPERAND (node, 1); tree index_type = TREE_TYPE (index); - tree promoted_index_type; int error_found = 0; EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); - if (not_initialized_as_it_should_p (array)) - { - ERROR_VARIABLE_NOT_INITIALIZED (wfl_array, DECL_NAME (array)); - INITIALIZED_P (array) = 1; - } - if (! flag_emit_class_files) - array = save_expr (array); - if (TREE_CODE (array_type) == POINTER_TYPE) array_type = TREE_TYPE (array_type); @@ -9998,47 +12561,48 @@ patch_array_ref (node, wfl_array, wfl_index) { parse_error_context (wfl_operator, "`[]' can only be applied to arrays. It can't be " - "applied to `%s'", lang_printable_name (array_type)); + "applied to `%s'", lang_printable_name (array_type, 0)); TREE_TYPE (node) = error_mark_node; error_found = 1; } /* The array index underdoes unary numeric promotion. The promoted type must be int */ - promoted_index_type = promote_type (index_type); - if (promoted_index_type != int_type_node) + index = do_unary_numeric_promotion (index); + if (TREE_TYPE (index) != int_type_node) { - int could_cast = can_cast_to_p (index_type, int_type_node); + int could_cast = valid_cast_to_p (index_type, int_type_node); parse_error_context (wfl_operator, (could_cast ? "Incompatible type for `[]'. Explicit cast needed to " "convert `%s' to `int'" : "Incompatible type for `[]'. " "Can't convert `%s' to `int'"), - lang_printable_name (index_type)); + lang_printable_name (index_type, 0)); TREE_TYPE (node) = error_mark_node; error_found = 1; } - /* Now if the index is a var/parm decl, check on its initialization */ - if (not_initialized_as_it_should_p (index)) - { - ERROR_VARIABLE_NOT_INITIALIZED (wfl_index, DECL_NAME (index)); - INITIALIZED_P (index) = 1; - } - if (error_found) return error_mark_node; - index = convert (promoted_index_type, index); - if (TREE_CODE (array_type) == RECORD_TYPE) - array_type = promote_type (TYPE_ARRAY_ELEMENT (array_type)); + array_type = TYPE_ARRAY_ELEMENT (array_type); + if (flag_emit_class_files) { - TREE_OPERAND (node, 0)= array; - TREE_OPERAND (node, 1)= index; + TREE_OPERAND (node, 0) = array; + TREE_OPERAND (node, 1) = index; } else - node = build_java_arrayaccess (array, array_type, index); + { + /* The save_expr is for correct evaluation order. It would be cleaner + to use force_evaluation_order (see comment there), but that is + difficult when we also have to deal with bounds checking. */ + if (TREE_SIDE_EFFECTS (index)) + array = save_expr (array); + node = build_java_arrayaccess (array, array_type, index); + if (TREE_SIDE_EFFECTS (index)) + node = build (COMPOUND_EXPR, array_type, array, node); + } TREE_TYPE (node) = array_type; return node; } @@ -10052,9 +12616,8 @@ build_newarray_node (type, dims, extra_dims) int extra_dims; { tree node = - build (CALL_EXPR, NULL_TREE, type, nreverse (dims), + build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims), build_int_2 (extra_dims, 0)); - TREE_SET_CODE (node, JAVA_NEW_ARRAY_EXPR); return node; } @@ -10068,7 +12631,6 @@ patch_newarray (node) int error_found = 0; int ndims = 0; int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2)); - int total_dims; /* Dimension types are verified. It's better for the types to be verified in order. */ @@ -10088,7 +12650,7 @@ patch_newarray (node) promoted type must be int. */ else { - dim = convert (promote_type (TREE_TYPE (dim)), dim); + dim = do_unary_numeric_promotion (dim); if (TREE_TYPE (dim) != int_type_node) dim_error = 1; } @@ -10100,18 +12662,9 @@ patch_newarray (node) (TREE_PURPOSE (cdim), "Incompatible type for dimension in array creation expression. " "%s convert `%s' to `int'", - (can_cast_to_p (TREE_TYPE (dim), int_type_node) ? + (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ? "Explicit cast needed to" : "Can't"), - lang_printable_name (TREE_TYPE (dim))); - error_found = 1; - } - - /* Check for uninitialized variables */ - if (not_initialized_as_it_should_p (dim)) - { - ERROR_VARIABLE_NOT_INITIALIZED (TREE_PURPOSE (cdim), - DECL_NAME (dim)); - INITIALIZED_P (dim) = 1; + lang_printable_name (TREE_TYPE (dim), 0)); error_found = 1; } @@ -10130,68 +12683,199 @@ patch_newarray (node) return error_mark_node; } + /* Set array_type to the actual (promoted) array type of the result. */ + if (TREE_CODE (type) == RECORD_TYPE) + type = build_pointer_type (type); + while (--xdims >= 0) + { + type = promote_type (build_java_array_type (type, -1)); + } + dims = nreverse (dims); + array_type = type; + for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim)) + { + type = array_type; + array_type = build_java_array_type (type, + TREE_CODE (cdim) == INTEGER_CST ? + TREE_INT_CST_LOW (cdim) : -1); + array_type = promote_type (array_type); + } + dims = nreverse (dims); + /* The node is transformed into a function call. Things are done differently according to the number of dimensions. If the number of dimension is equal to 1, then the nature of the base type (primitive or not) matters. */ - total_dims = xdims + ndims; - if (total_dims == 1) + if (ndims == 1) + return build_new_array (type, TREE_VALUE (dims)); + + /* Can't reuse what's already written in expr.c because it uses the + JVM stack representation. Provide a build_multianewarray. FIXME */ + return build (CALL_EXPR, array_type, + build_address_of (soft_multianewarray_node), + tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)), + tree_cons (NULL_TREE, + build_int_2 (ndims, 0), dims )), + NULL_TREE); +} + +/* 10.6 Array initializer. */ + +/* Build a wfl for array element that don't have one, so we can + pin-point errors. */ + +static tree +maybe_build_array_element_wfl (node) + tree node; +{ + if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION) + return build_expr_wfl (NULL_TREE, ctxp->filename, + ctxp->elc.line, ctxp->elc.prev_col); + else + return NULL_TREE; +} + +/* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes + identification of initialized arrays easier to detect during walk + and expansion. */ + +static tree +build_new_array_init (location, values) + int location; + tree values; +{ + tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values); + tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor); + EXPR_WFL_LINECOL (to_return) = location; + return to_return; +} + +/* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error + occurred. Otherwise return NODE after having set its type + appropriately. */ + +static tree +patch_new_array_init (type, node) + tree type, node; +{ + int error_seen = 0; + tree current, element_type; + HOST_WIDE_INT length; + int all_constant = 1; + tree init = TREE_OPERAND (node, 0); + + if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type))) { - if (JPRIMITIVE_TYPE_P (type)) + parse_error_context (node, + "Invalid array initializer for non-array type `%s'", + lang_printable_name (type, 1)); + return error_mark_node; + } + type = TREE_TYPE (type); + element_type = TYPE_ARRAY_ELEMENT (type); + + CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init)); + + for (length = 0, current = CONSTRUCTOR_ELTS (init); + current; length++, current = TREE_CHAIN (current)) + { + tree elt = TREE_VALUE (current); + if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT) { - int type_code; - if (type == boolean_type_node) - type_code = 4; - else if (type == char_type_node) - type_code = 5; - else if (type == float_type_node) - type_code = 6; - else if (type == double_type_node) - type_code = 7; - else if (type == byte_type_node) - type_code = 8; - else if (type == short_type_node) - type_code = 9; - else if (type == int_type_node) - type_code = 10; - else if (type == long_type_node) - type_code = 11; - else - fatal ("Can't compute type code - patch_newarray"); - return build_newarray (type_code, TREE_VALUE (dims)); + error_seen |= array_constructor_check_entry (element_type, current); + elt = TREE_VALUE (current); + /* When compiling to native code, STRING_CST is converted to + INDIRECT_REF, but still with a TREE_CONSTANT flag. */ + if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF) + all_constant = 0; } else - return build_anewarray (type, TREE_VALUE (dims)); + { + TREE_VALUE (current) = patch_new_array_init (element_type, elt); + TREE_PURPOSE (current) = NULL_TREE; + all_constant = 0; + } + if (elt && TREE_VALUE (elt) == error_mark_node) + error_seen = 1; + } + + if (error_seen) + return error_mark_node; + + /* Create a new type. We can't reuse the one we have here by + patching its dimension because it originally is of dimension -1 + hence reused by gcc. This would prevent triangular arrays. */ + type = build_java_array_type (element_type, length); + TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type)))); + TREE_TYPE (node) = promote_type (type); + TREE_CONSTANT (init) = all_constant; + TREE_CONSTANT (node) = all_constant; + return node; +} + +/* Verify that one entry of the initializer element list can be + assigned to the array base type. Report 1 if an error occurred, 0 + otherwise. */ + +static int +array_constructor_check_entry (type, entry) + tree type, entry; +{ + char *array_type_string = NULL; /* For error reports */ + tree value, type_value, new_value, wfl_value, patched; + int error_seen = 0; + + new_value = NULL_TREE; + wfl_value = TREE_VALUE (entry); + + value = java_complete_tree (TREE_VALUE (entry)); + /* patch_string return error_mark_node if arg is error_mark_node */ + if ((patched = patch_string (value))) + value = patched; + if (value == error_mark_node) + return 1; + + type_value = TREE_TYPE (value); + + /* At anytime, try_builtin_assignconv can report a warning on + constant overflow during narrowing. */ + SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value); + new_value = try_builtin_assignconv (wfl_operator, type, value); + if (!new_value && (new_value = try_reference_assignconv (type, value))) + type_value = promote_type (type); + + /* Check and report errors */ + if (!new_value) + { + char *msg = (!valid_cast_to_p (type_value, type) ? + "Can't" : "Explicit cast needed to"); + if (!array_type_string) + array_type_string = strdup (lang_printable_name (type, 1)); + parse_error_context + (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'", + msg, lang_printable_name (type_value, 1), array_type_string); + error_seen = 1; } - /* Add extra dimensions as unknown dimensions */ - while (xdims--) - dims = - chainon (dims, build_tree_list (NULL_TREE, integer_negative_one_node)); - dims = chainon (dims, build_tree_list (NULL_TREE, integer_zero_node)); + if (new_value) + { + new_value = maybe_build_primttype_type_ref (new_value, wfl_operator); + TREE_VALUE (entry) = new_value; + } - /* Can't reuse what's already written in expr.c because it uses the - JVM stack representation. Provide a build_multianewarray. FIXME */ - array_type = type; - for (cdim = TREE_CHAIN (dims); cdim; cdim = TREE_CHAIN (cdim)) - array_type = build_java_array_type (promote_type (array_type), - TREE_CODE (cdim) == INTEGER_CST ? - TREE_INT_CST_LOW (cdim) : -1); - return build (CALL_EXPR, - promote_type (array_type), - build_address_of (soft_multianewarray_node), - tree_cons (NULL_TREE, build_class_ref (array_type), - tree_cons (NULL_TREE, - build_int_2 (total_dims, 0), dims )), - NULL_TREE); + if (array_type_string) + free (array_type_string); + + TREE_PURPOSE (entry) = NULL_TREE; + return error_seen; } static tree build_this (location) int location; { - tree node = build_wfl_node (this_identifier_node, input_filename, 0, 0); - TREE_SET_CODE (node, JAVA_THIS_EXPR); + tree node = build_wfl_node (this_identifier_node); + TREE_SET_CODE (node, THIS_EXPR); EXPR_WFL_LINECOL (node) = location; return node; } @@ -10207,6 +12891,7 @@ build_return (location, op) { tree node = build1 (RETURN_EXPR, NULL_TREE, op); EXPR_WFL_LINECOL (node) = location; + node = build_debugable_stmt (location, node); return node; } @@ -10217,7 +12902,6 @@ patch_return (node) tree return_exp = TREE_OPERAND (node, 0); tree meth = current_function_decl; tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl)); - tree modify; int error_found = 0; TREE_TYPE (node) = error_mark_node; @@ -10228,6 +12912,10 @@ patch_return (node) if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth))) error_found = 1; + /* It's invalid to use a return statement in a static block */ + if (DECL_NAME (current_function_decl) == clinit_identifier_node) + error_found = 1; + /* It's invalid to have a no return value within a function that isn't declared with the keyword `void' */ if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth))) @@ -10235,20 +12923,53 @@ patch_return (node) if (error_found) { - char *t = strdup ((char *)lang_printable_name (mtype)); - parse_error_context (wfl_operator, "`return' with%s value from `%s %s'", - (error_found == 1 ? "" : "out"), t, - lang_printable_name (meth)); - free (t); + if (DECL_NAME (current_function_decl) == clinit_identifier_node) + parse_error_context (wfl_operator, + "`return' inside static initializer."); + + else if (!DECL_CONSTRUCTOR_P (meth)) + { + char *t = strdup (lang_printable_name (mtype, 0)); + parse_error_context (wfl_operator, + "`return' with%s value from `%s %s'", + (error_found == 1 ? "" : "out"), + t, lang_printable_name (meth, 0)); + free (t); + } + else + parse_error_context (wfl_operator, + "`return' with value from constructor `%s'", + lang_printable_name (meth, 0)); return error_mark_node; } - /* If we have a return_exp, build a modify expression and expand it */ + /* If we have a return_exp, build a modify expression and expand + it. Note: at that point, the assignment is declared valid, but we + may want to carry some more hacks */ if (return_exp) { - modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), return_exp); + tree exp = java_complete_tree (return_exp); + tree modify, patched; + + /* If the function returned value and EXP are booleans, EXP has + to be converted into the type of DECL_RESULT, which is integer + (see complete_start_java_method) */ + if (TREE_TYPE (exp) == boolean_type_node && + TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node) + exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp); + + /* `null' can be assigned to a function returning a reference */ + if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) && + exp == null_pointer_node) + exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth))); + + if ((patched = patch_string (exp))) + exp = patched; + + modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp); EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node); modify = java_complete_tree (modify); + if (modify != error_mark_node) { TREE_SIDE_EFFECTS (modify) = 1; @@ -10270,12 +12991,11 @@ build_if_else_statement (location, expression, if_body, else_body) tree expression, if_body, else_body; { tree node; - /* FIXME: make else body be a void node, where this function is - called */ if (!else_body) - else_body = build (COMPOUND_EXPR, void_type_node, NULL_TREE, NULL_TREE); + else_body = empty_stmt_node; node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body); EXPR_WFL_LINECOL (node) = location; + node = build_debugable_stmt (location, node); return node; } @@ -10289,17 +13009,21 @@ patch_if_else_statement (node) EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); /* The type of expression must be boolean */ - if (TREE_TYPE (expression) != boolean_type_node) + if (TREE_TYPE (expression) != boolean_type_node + && TREE_TYPE (expression) != promoted_boolean_type_node) { parse_error_context (wfl_operator, "Incompatible type for `if'. Can't convert `%s' to `boolean'", - lang_printable_name (TREE_TYPE (expression))); + lang_printable_name (TREE_TYPE (expression), 0)); return error_mark_node; } TREE_TYPE (node) = void_type_node; TREE_SIDE_EFFECTS (node) = 1; + CAN_COMPLETE_NORMALLY (node) + = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)) + | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)); return node; } @@ -10307,30 +13031,35 @@ patch_if_else_statement (node) /* Action taken when a lableled statement is parsed. a new LABELED_BLOCK_EXPR is created. No statement is attached to the - label, yet. */ + label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */ static tree -build_labeled_block (location, label, wfl) +build_labeled_block (location, label) int location; - tree label, wfl; + tree label; { - tree label_name = merge_qualified_name (label_id, label); + tree label_name ; tree label_decl, node; - - /* Issue a warning if we try to reuse a label that was previously - declared */ - if (IDENTIFIER_LOCAL_VALUE (label_name)) + if (label == NULL_TREE || label == continue_identifier_node) + label_name = label; + else { - EXPR_WFL_LINECOL (wfl_operator) = location; - parse_warning_context (wfl_operator, "Declaration of `%s' shadows " - "a previous declaration", - IDENTIFIER_POINTER (label)); - EXPR_WFL_LINECOL (wfl_operator) = - EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name)); - parse_warning_context (wfl_operator, "This is the location of the " - "previous declaration of label `%s'", - IDENTIFIER_POINTER (label)); - java_warning_count--; + label_name = merge_qualified_name (label_id, label); + /* Issue an error if we try to reuse a label that was previously + declared */ + if (IDENTIFIER_LOCAL_VALUE (label_name)) + { + EXPR_WFL_LINECOL (wfl_operator) = location; + parse_error_context (wfl_operator, "Declaration of `%s' shadows " + "a previous label declaration", + IDENTIFIER_POINTER (label)); + EXPR_WFL_LINECOL (wfl_operator) = + EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name)); + parse_error_context (wfl_operator, "This is the location of the " + "previous declaration of label `%s'", + IDENTIFIER_POINTER (label)); + java_error_count--; + } } label_decl = create_label_decl (label_name); @@ -10340,27 +13069,10 @@ build_labeled_block (location, label, wfl) return node; } -/* Generate a label crafting a unique name for it. This is used to - implicitely label loops that aren't the body part of labeled - statement. */ - -static tree -generate_labeled_block () -{ - static int l_number = 0; - char buf [20]; - tree label_name; - - sprintf (buf, "$a%d", l_number++); - return build_labeled_block (0, get_identifier (buf), NULL_TREE); -} - -/* A labeled statement LBE is attached a statement. If the statement - happens to be a loop, a link from the loop back to the label is - installed. */ +/* A labeled statement LBE is attached a statement. */ static tree -complete_labeled_statement (lbe, statement) +finish_labeled_statement (lbe, statement) tree lbe; /* Labeled block expr */ tree statement; { @@ -10373,9 +13085,10 @@ complete_labeled_statement (lbe, statement) if (TREE_CODE (statement) == LOOP_EXPR && IS_FOR_LOOP_P (statement)) { java_method_add_stmt (current_function_decl, lbe); - return exit_block (); + lbe = exit_block (); } - + pop_labeled_block (); + POP_LABELED_BLOCK (); return lbe; } @@ -10399,12 +13112,20 @@ build_new_loop (loop_body) COMPOUND_EXPR (loop main body) EXIT_EXPR (this order is for while/for loops. LABELED_BLOCK_EXPR the order is reversed for do loops) - LABEL_DECL (continue occurding here branche at the + LABEL_DECL (a continue occuring here branches at the BODY end of this labeled block) INCREMENT (if any) REVERSED, if non zero, tells that the loop condition expr comes - after the body, like in the do-while loop. */ + after the body, like in the do-while loop. + + To obtain a loop, the loop body structure described above is + encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR: + + LABELED_BLOCK_EXPR + LABEL_DECL (use this label to exit the loop) + LOOP_EXPR + <structure described above> */ static tree build_loop_body (location, condition, reversed) @@ -10412,19 +13133,19 @@ build_loop_body (location, condition, reversed) tree condition; int reversed; { - tree first, second, label, body; + tree first, second, body; condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */ EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */ condition = build_debugable_stmt (location, condition); TREE_SIDE_EFFECTS (condition) = 1; - body = generate_labeled_block (); + body = build_labeled_block (0, continue_identifier_node); first = (reversed ? body : condition); second = (reversed ? condition : body); return build (COMPOUND_EXPR, NULL_TREE, - build (COMPOUND_EXPR, NULL_TREE, first, second), size_zero_node); + build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node); } /* Install CONDITION (if any) and loop BODY (using REVERSED to tell @@ -10432,7 +13153,7 @@ build_loop_body (location, condition, reversed) loop list. */ static tree -complete_loop_body (location, condition, body, reversed) +finish_loop_body (location, condition, body, reversed) int location; tree condition, body; int reversed; @@ -10454,16 +13175,16 @@ complete_loop_body (location, condition, body, reversed) return to_return; } -/* Tailored version of complete_loop_body for FOR loops, when FOR +/* Tailored version of finish_loop_body for FOR loops, when FOR loops feature the condition part */ static tree -complete_for_loop (location, condition, update, body) +finish_for_loop (location, condition, update, body) int location; tree condition, update, body; { /* Put the condition and the loop body in place */ - tree loop = complete_loop_body (location, condition, body, 0); + tree loop = finish_loop_body (location, condition, body, 0); /* LOOP is the current loop which has been now popped of the loop stack. Install the update block */ LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update; @@ -10471,28 +13192,21 @@ complete_for_loop (location, condition, update, body) } /* If the loop isn't surrounded by a labeled statement, create one and - insert LOOP as it's body. */ + insert LOOP as its body. */ static tree patch_loop_statement (loop) tree loop; { - tree cbl, loop_label, to_return_as_loop; - - if (LOOP_HAS_LABEL_P (loop)) - { - loop_label = ctxp->current_labeled_block; - to_return_as_loop = loop; - } - else + if (! LOOP_HAS_LABEL_P (loop)) { - loop_label = generate_labeled_block (); + tree loop_label = build_labeled_block (0, NULL_TREE); LABELED_BLOCK_BODY (loop_label) = loop; PUSH_LABELED_BLOCK (loop_label); - to_return_as_loop = loop_label; + loop = loop_label; } - TREE_TYPE (to_return_as_loop) = void_type_node; - return to_return_as_loop; + TREE_TYPE (loop) = void_type_node; + return loop; } /* 14.13, 14.14: break and continue Statements */ @@ -10525,6 +13239,7 @@ build_bc_statement (location, is_break, name) IS_BREAK_STMT_P (break_continue) = is_break; TREE_SIDE_EFFECTS (break_continue) = 1; EXPR_WFL_LINECOL (break_continue) = location; + break_continue = build_debugable_stmt (location, break_continue); return break_continue; } @@ -10535,79 +13250,65 @@ patch_bc_statement (node) tree node; { tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt; - int is_unlabeled = 0; - EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + tree labeled_block = ctxp->current_labeled_block; + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); - /* Not having a target means that the break/continue statement is - unlabeled. We try to find a descent label for it */ - if (!bc_label) - { - is_unlabeled = 1; - /* There should be a loop to branch to */ - if (ctxp->current_loop) - { - /* At that stage, we're in the loop body, which is - encapsulated around a LABELED_BLOCK_EXPR. So searching - the current loop label requires us to consider the - labeled block before the current one. */ - if (!LOOP_HAS_LABEL_SKIP_P (ctxp->current_loop)) - fatal ("unlabeled loop has not installed label -- " - "patch_bc_statement"); - bc_label = TREE_CHAIN (ctxp->current_labeled_block); - } - /* Not having a loop to break/continue to is an error */ - else - { - parse_error_context (wfl_operator, "`%s' must be in loop%s", - (IS_BREAK_STMT_P (node) ? "break" : "continue"), - (IS_BREAK_STMT_P (node) ? " or switch" : "")); - return error_mark_node; - } - } /* Having an identifier here means that the target is unknown. */ - else if (TREE_CODE (bc_label) == IDENTIFIER_NODE) + if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE) { parse_error_context (wfl_operator, "No label definition found for `%s'", IDENTIFIER_POINTER (bc_label)); return error_mark_node; } - - /* Find the statement we're targeting. */ - target_stmt = LABELED_BLOCK_BODY (bc_label); - - /* 14.13 The break Statement */ - if (IS_BREAK_STMT_P (node)) + if (! IS_BREAK_STMT_P (node)) { - /* Named break are always fine, as far as they have a target - (already verified). Anonymous break need to target - while/do/for/switch */ - if (is_unlabeled && - !(TREE_CODE (target_stmt) == LOOP_EXPR /* do/while/for */ - || 0)) /* switch FIXME */ + /* It's a continue statement. */ + for (;; labeled_block = TREE_CHAIN (labeled_block)) { - parse_error_context (wfl_operator, - "`break' must be in loop or switch"); - return error_mark_node; + if (labeled_block == NULL_TREE) + { + if (bc_label == NULL_TREE) + parse_error_context (wfl_operator, + "`continue' must be in loop"); + else + parse_error_context (wfl_operator, + "continue label `%d' does not name a loop", + IDENTIFIER_POINTER (bc_label)); + return error_mark_node; + } + if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block)) + == continue_identifier_node) + && (bc_label == NULL_TREE + || TREE_CHAIN (labeled_block) == bc_label)) + { + bc_label = labeled_block; + break; + } } - /* If previously unlabeled, install the new found label */ - if (is_unlabeled) - EXIT_BLOCK_LABELED_BLOCK (node) = bc_label; } - /* 14.14 The continue Statement */ - /* The continue statement must always target a loop */ - else - { - if (TREE_CODE (target_stmt) != LOOP_EXPR) /* do/while/for */ + else if (!bc_label) + { + for (;; labeled_block = TREE_CHAIN (labeled_block)) { - parse_error_context (wfl_operator, "`continue' must be in loop"); - return error_mark_node; + if (labeled_block == NULL_TREE) + { + parse_error_context (wfl_operator, + "`break' must be in loop or switch"); + return error_mark_node; + } + target_stmt = LABELED_BLOCK_BODY (labeled_block); + if (TREE_CODE (target_stmt) == SWITCH_EXPR + || TREE_CODE (target_stmt) == LOOP_EXPR) + { + bc_label = labeled_block; + break; + } } - /* Everything looks good. We can fix the `continue' jump to go - at the place in the loop were the continue is. The continue - is the current labeled block, by construction. */ - EXIT_BLOCK_LABELED_BLOCK (node) = ctxp->current_labeled_block; } + EXIT_BLOCK_LABELED_BLOCK (node) = bc_label; + CAN_COMPLETE_NORMALLY (bc_label) = 1; + /* Our break/continue don't return values. */ TREE_TYPE (node) = void_type_node; /* Encapsulate the break within a compound statement so that it's @@ -10636,13 +13337,686 @@ patch_exit_expr (node) (wfl_operator, "Incompatible type for loop conditional. Can't convert `%s' to " "`boolean'", - lang_printable_name (TREE_TYPE (expression))); + lang_printable_name (TREE_TYPE (expression), 0)); return error_mark_node; } /* Now we know things are allright, invert the condition, fold and return */ TREE_OPERAND (node, 0) = fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression)); + + if (! integer_zerop (TREE_OPERAND (node, 0)) + && ctxp->current_loop != NULL_TREE + && TREE_CODE (ctxp->current_loop) == LOOP_EXPR) + CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1; + if (! integer_onep (TREE_OPERAND (node, 0))) + CAN_COMPLETE_NORMALLY (node) = 1; + + TREE_TYPE (node) = void_type_node; return node; } + +/* 14.9 Switch statement */ + +static tree +patch_switch_statement (node) + tree node; +{ + tree se = TREE_OPERAND (node, 0), se_type; + + /* Complete the switch expression */ + se = TREE_OPERAND (node, 0) = java_complete_tree (se); + se_type = TREE_TYPE (se); + /* The type of the switch expression must be char, byte, short or + int */ + if (!JINTEGRAL_TYPE_P (se_type)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + parse_error_context (wfl_operator, "Incompatible type for `switch'. " + "Can't convert `%s' to `int'", + lang_printable_name (se_type, 0)); + /* This is what java_complete_tree will check */ + TREE_OPERAND (node, 0) = error_mark_node; + return error_mark_node; + } + + TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1)); + + /* Ready to return */ + if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK) + { + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } + TREE_TYPE (node) = void_type_node; + TREE_SIDE_EFFECTS (node) = 1; + CAN_COMPLETE_NORMALLY (node) + = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)) + || ! SWITCH_HAS_DEFAULT (node); + return node; +} + +/* 14.18 The try statement */ + +static tree +build_try_statement (location, try_block, catches) + int location; + tree try_block, catches; +{ + tree node = build (TRY_EXPR, NULL_TREE, try_block, catches); + EXPR_WFL_LINECOL (node) = location; + return node; +} + +static tree +build_try_finally_statement (location, try_block, finally) + int location; + tree try_block, finally; +{ + tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally); + EXPR_WFL_LINECOL (node) = location; + return node; +} + +static tree +patch_try_statement (node) + tree node; +{ + int error_found = 0; + tree try = TREE_OPERAND (node, 0); + /* Exception handlers are considered in left to right order */ + tree catch = nreverse (TREE_OPERAND (node, 1)); + tree current, caught_type_list = NULL_TREE; + + /* Check catch clauses, if any. Every time we find an error, we try + to process the next catch clause. We process the catch clause before + the try block so that when processing the try block we can check thrown + exceptions againts the caught type list. */ + for (current = catch; current; current = TREE_CHAIN (current)) + { + tree carg_decl, carg_type; + tree sub_current, catch_block, catch_clause; + int unreachable; + + /* At this point, the structure of the catch clause is + CATCH_EXPR (catch node) + BLOCK (with the decl of the parameter) + COMPOUND_EXPR + MODIFY_EXPR (assignment of the catch parameter) + BLOCK (catch clause block) + */ + catch_clause = TREE_OPERAND (current, 0); + carg_decl = BLOCK_EXPR_DECLS (catch_clause); + carg_type = TREE_TYPE (TREE_TYPE (carg_decl)); + + /* Catch clauses can't have more than one parameter declared, + but it's already enforced by the grammar. Make sure that the + only parameter of the clause statement in of class Throwable + or a subclass of Throwable, but that was done earlier. The + catch clause parameter type has also been resolved. */ + + /* Just make sure that the catch clause parameter type inherits + from java.lang.Throwable */ + if (!inherits_from_p (carg_type, throwable_type_node)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current); + parse_error_context (wfl_operator, + "Can't catch class `%s'. Catch clause " + "parameter type must be a subclass of " + "class `java.lang.Throwable'", + lang_printable_name (carg_type, 0)); + error_found = 1; + continue; + } + + /* Partial check for unreachable catch statement: The catch + clause is reachable iff is no earlier catch block A in + the try statement such that the type of the catch + clause's parameter is the same as or a subclass of the + type of A's parameter */ + unreachable = 0; + for (sub_current = catch; + sub_current != current; sub_current = TREE_CHAIN (sub_current)) + { + tree sub_catch_clause, decl; + sub_catch_clause = TREE_OPERAND (sub_current, 0); + decl = BLOCK_EXPR_DECLS (sub_catch_clause); + + if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl)))) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current); + parse_error_context + (wfl_operator, "`catch' not reached because of the catch " + "clause at line %d", EXPR_WFL_LINENO (sub_current)); + unreachable = error_found = 1; + break; + } + } + /* Complete the catch clause block */ + catch_block = java_complete_tree (TREE_OPERAND (current, 0)); + if (catch_block == error_mark_node) + { + error_found = 1; + continue; + } + if (CAN_COMPLETE_NORMALLY (catch_block)) + CAN_COMPLETE_NORMALLY (node) = 1; + TREE_OPERAND (current, 0) = catch_block; + + if (unreachable) + continue; + + /* Things to do here: the exception must be thrown */ + + /* Link this type to the caught type list */ + caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list); + } + + PUSH_EXCEPTIONS (caught_type_list); + if ((try = java_complete_tree (try)) == error_mark_node) + error_found = 1; + if (CAN_COMPLETE_NORMALLY (try)) + CAN_COMPLETE_NORMALLY (node) = 1; + POP_EXCEPTIONS (); + + /* Verification ends here */ + if (error_found) + return error_mark_node; + + TREE_OPERAND (node, 0) = try; + TREE_OPERAND (node, 1) = catch; + TREE_TYPE (node) = void_type_node; + return node; +} + +/* 14.17 The synchronized Statement */ + +static tree +patch_synchronized_statement (node, wfl_op1) + tree node, wfl_op1; +{ + tree expr = java_complete_tree (TREE_OPERAND (node, 0)); + tree block = TREE_OPERAND (node, 1); + + tree enter, exit, expr_decl, assignment; + + if (expr == error_mark_node) + { + block = java_complete_tree (block); + return expr; + } + + /* The TYPE of expr must be a reference type */ + if (!JREFERENCE_TYPE_P (TREE_TYPE (expr))) + { + SET_WFL_OPERATOR (wfl_operator, node, wfl_op1); + parse_error_context (wfl_operator, "Incompatible type for `synchronized'" + ". Can't convert `%s' to `java.lang.Object'", + lang_printable_name (TREE_TYPE (expr), 0)); + return error_mark_node; + } + + /* Generate a try-finally for the synchronized statement, except + that the handler that catches all throw exception calls + _Jv_MonitorExit and then rethrow the exception. + The synchronized statement is then implemented as: + TRY + { + _Jv_MonitorEnter (expression) + synchronized_block + _Jv_MonitorExit (expression) + } + CATCH_ALL + { + e = _Jv_exception_info (); + _Jv_MonitorExit (expression) + Throw (e); + } */ + + expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr)); + BUILD_MONITOR_ENTER (enter, expr_decl); + BUILD_MONITOR_EXIT (exit, expr_decl); + CAN_COMPLETE_NORMALLY (enter) = 1; + CAN_COMPLETE_NORMALLY (exit) = 1; + assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr); + TREE_SIDE_EFFECTS (assignment) = 1; + node = build1 (CLEANUP_POINT_EXPR, NULL_TREE, + build (COMPOUND_EXPR, NULL_TREE, + build (WITH_CLEANUP_EXPR, NULL_TREE, + build (COMPOUND_EXPR, NULL_TREE, + assignment, enter), + NULL_TREE, exit), + block)); + node = build_expr_block (node, expr_decl); + + return java_complete_tree (node); +} + +/* 14.16 The throw Statement */ + +static tree +patch_throw_statement (node, wfl_op1) + tree node, wfl_op1; +{ + tree expr = TREE_OPERAND (node, 0); + tree type = TREE_TYPE (expr); + int unchecked_ok = 0, tryblock_throws_ok = 0; + + /* Thrown expression must be assignable to java.lang.Throwable */ + if (!try_reference_assignconv (throwable_type_node, expr)) + { + SET_WFL_OPERATOR (wfl_operator, node, wfl_op1); + parse_error_context (wfl_operator, "Can't throw `%s'; it must be a " + "subclass of class `java.lang.Throwable'", + lang_printable_name (type, 0)); + /* If the thrown expression was a reference, we further the + compile-time check. */ + if (!JREFERENCE_TYPE_P (type)) + return error_mark_node; + } + + /* At least one of the following must be true */ + + /* The type of the throw expression is a not checked exception, + i.e. is a unchecked expression. */ + unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type)); + + /* Throw is contained in a try statement and at least one catch + clause can receive the thrown expression or the current method is + declared to throw such an exception. Or, the throw statement is + contained in a method or constructor declaration and the type of + the Expression is assignable to at least one type listed in the + throws clause the declaration. */ + SET_WFL_OPERATOR (wfl_operator, node, wfl_op1); + if (!unchecked_ok) + tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr)); + if (!(unchecked_ok || tryblock_throws_ok)) + { + /* If there is a surrounding try block that has no matching + clatch clause, report it first. A surrounding try block exits + only if there is something after the list of checked + exception thrown by the current function (if any). */ + if (IN_TRY_BLOCK_P ()) + parse_error_context (wfl_operator, "Checked exception `%s' can't be " + "caught by any of the catch clause(s) " + "of the surrounding `try' block", + lang_printable_name (type, 0)); + /* If we have no surrounding try statement and the method doesn't have + any throws, report it now. FIXME */ + + /* We report that the exception can't be throw from a try block + in all circumstances but when the `throw' is inside a static + block. */ + else if (!EXCEPTIONS_P (currently_caught_type_list) + && !tryblock_throws_ok) + { + if (DECL_NAME (current_function_decl) == clinit_identifier_node) + parse_error_context (wfl_operator, "Checked exception `%s' can't " + "be thrown in initializer", + lang_printable_name (type, 0)); + else + parse_error_context (wfl_operator, "Checked exception `%s' isn't " + "thrown from a `try' block", + lang_printable_name (type, 0)); + } + /* Otherwise, the current method doesn't have the appropriate + throws declaration */ + else + parse_error_context (wfl_operator, "Checked exception `%s' doesn't " + "match any of current method's `throws' " + "declaration(s)", + lang_printable_name (type, 0)); + return error_mark_node; + } + + if (! flag_emit_class_files) + BUILD_THROW (node, expr); + return node; +} + +/* Check that exception said to be thrown by method DECL can be + effectively caught from where DECL is invoked. */ + +static void +check_thrown_exceptions (location, decl) + int location; + tree decl; +{ + tree throws; + /* For all the unchecked exceptions thrown by DECL */ + for (throws = DECL_FUNCTION_THROWS (decl); throws; + throws = TREE_CHAIN (throws)) + if (!check_thrown_exceptions_do (TREE_VALUE (throws))) + { +#if 1 + /* Temporary hack to suppresses errors about cloning arrays. FIXME */ + if (DECL_NAME (decl) == get_identifier ("clone")) + continue; +#endif + EXPR_WFL_LINECOL (wfl_operator) = location; + parse_error_context + (wfl_operator, "Exception `%s' must be caught, or it must be " + "declared in the `throws' clause of `%s'", + lang_printable_name (TREE_VALUE (throws), 0), + IDENTIFIER_POINTER (DECL_NAME (current_function_decl))); + } +} + +/* Return 1 if checked EXCEPTION is caught at the current nesting level of + try-catch blocks, OR is listed in the `throws' clause of the + current method. */ + +static int +check_thrown_exceptions_do (exception) + tree exception; +{ + tree list = currently_caught_type_list; + resolve_and_layout (exception, NULL_TREE); + /* First, all the nested try-catch-finally at that stage. The + last element contains `throws' clause exceptions, if any. */ + if (IS_UNCHECKED_EXCEPTION_P (exception)) + return 1; + while (list) + { + tree caught; + for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught)) + if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0)) + return 1; + list = TREE_CHAIN (list); + } + return 0; +} + +static void +purge_unchecked_exceptions (mdecl) + tree mdecl; +{ + tree throws = DECL_FUNCTION_THROWS (mdecl); + tree new = NULL_TREE; + + while (throws) + { + tree next = TREE_CHAIN (throws); + if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws))) + { + TREE_CHAIN (throws) = new; + new = throws; + } + throws = next; + } + /* List is inverted here, but it doesn't matter */ + DECL_FUNCTION_THROWS (mdecl) = new; +} + +/* 15.24 Conditional Operator ?: */ + +static tree +patch_conditional_expr (node, wfl_cond, wfl_op1) + tree node, wfl_cond, wfl_op1; +{ + tree cond = TREE_OPERAND (node, 0); + tree op1 = TREE_OPERAND (node, 1); + tree op2 = TREE_OPERAND (node, 2); + tree resulting_type = NULL_TREE; + tree t1, t2, patched; + int error_found = 0; + + /* Operands of ?: might be StringBuffers crafted as a result of a + string concatenation. Obtain a descent operand here. */ + if ((patched = patch_string (op1))) + TREE_OPERAND (node, 1) = op1 = patched; + if ((patched = patch_string (op2))) + TREE_OPERAND (node, 2) = op2 = patched; + + t1 = TREE_TYPE (op1); + t2 = TREE_TYPE (op2); + + /* The first expression must be a boolean */ + if (TREE_TYPE (cond) != boolean_type_node) + { + SET_WFL_OPERATOR (wfl_operator, node, wfl_cond); + parse_error_context (wfl_operator, "Incompatible type for `?:'. Can't " + "convert `%s' to `boolean'", + lang_printable_name (TREE_TYPE (cond), 0)); + error_found = 1; + } + + /* Second and third can be numeric, boolean (i.e. primitive), + references or null. Anything else results in an error */ + if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2)) + || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node) + && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node)) + || (t1 == boolean_type_node && t2 == boolean_type_node))) + error_found = 1; + + /* Determine the type of the conditional expression. Same types are + easy to deal with */ + else if (t1 == t2) + resulting_type = t1; + + /* There are different rules for numeric types */ + else if (JNUMERIC_TYPE_P (t1)) + { + /* if byte/short found, the resulting type is short */ + if ((t1 == byte_type_node && t2 == short_type_node) + || (t1 == short_type_node && t2 == byte_type_node)) + resulting_type = short_type_node; + + /* If t1 is a constant int and t2 is of type byte, short or char + and t1's value fits in t2, then the resulting type is t2 */ + else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1))) + && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2)) + resulting_type = t2; + + /* If t2 is a constant int and t1 is of type byte, short or char + and t2's value fits in t1, then the resulting type is t1 */ + else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2))) + && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1)) + resulting_type = t1; + + /* Otherwise, binary numeric promotion is applied and the + resulting type is the promoted type of operand 1 and 2 */ + else + resulting_type = binary_numeric_promotion (t2, t2, + &TREE_OPERAND (node, 1), + &TREE_OPERAND (node, 2)); + } + + /* Cases of a reference and a null type */ + else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node) + resulting_type = t1; + + else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node) + resulting_type = t2; + + /* Last case: different reference types. If a type can be converted + into the other one by assignment conversion, the latter + determines the type of the expression */ + else if ((resulting_type = try_reference_assignconv (t1, op2))) + resulting_type = promote_type (t1); + + else if ((resulting_type = try_reference_assignconv (t2, op1))) + resulting_type = promote_type (t2); + + /* If we don't have any resulting type, we're in trouble */ + if (!resulting_type) + { + char *t = strdup (lang_printable_name (t1, 0)); + SET_WFL_OPERATOR (wfl_operator, node, wfl_op1); + parse_error_context (wfl_operator, "Incompatible type for `?:'. Can't " + "convert `%s' to `%s'", t, + lang_printable_name (t2, 0)); + free (t); + error_found = 1; + } + + if (error_found) + { + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } + + TREE_TYPE (node) = resulting_type; + TREE_SET_CODE (node, COND_EXPR); + CAN_COMPLETE_NORMALLY (node) = 1; + return node; +} + +/* Try to constant fold NODE. + If NODE is not a constant expression, return NULL_EXPR. + CONTEXT is a static final VAR_DECL whose initializer we are folding. */ + +static tree +fold_constant_for_init (node, context) + tree node; + tree context; +{ + tree op0, op1, val; + enum tree_code code = TREE_CODE (node); + + if (code == INTEGER_CST || code == REAL_CST || code == STRING_CST) + return node; + if (TREE_TYPE (node) != NULL_TREE) + return NULL_TREE; + + switch (code) + { + case PLUS_EXPR: + case MINUS_EXPR: + case MULT_EXPR: + case TRUNC_MOD_EXPR: + case RDIV_EXPR: + case LSHIFT_EXPR: + case RSHIFT_EXPR: + case URSHIFT_EXPR: + case BIT_AND_EXPR: + case BIT_XOR_EXPR: + case BIT_IOR_EXPR: + case TRUTH_ANDIF_EXPR: + case TRUTH_ORIF_EXPR: + case EQ_EXPR: + case NE_EXPR: + case GT_EXPR: + case GE_EXPR: + case LT_EXPR: + case LE_EXPR: + op0 = TREE_OPERAND (node, 0); + op1 = TREE_OPERAND (node, 1); + val = fold_constant_for_init (op0, context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 0) = val; + val = fold_constant_for_init (op1, context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 1) = val; + return patch_binop (node, op0, op1); + + case UNARY_PLUS_EXPR: + case NEGATE_EXPR: + case TRUTH_NOT_EXPR: + case BIT_NOT_EXPR: + case CONVERT_EXPR: + op0 = TREE_OPERAND (node, 0); + val = fold_constant_for_init (op0, context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 0) = val; + return patch_unaryop (node, op0); + break; + + case COND_EXPR: + val = fold_constant_for_init (TREE_OPERAND (node, 0), context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 0) = val; + val = fold_constant_for_init (TREE_OPERAND (node, 1), context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 1) = val; + val = fold_constant_for_init (TREE_OPERAND (node, 2), context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 2) = val; + return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1) + : TREE_OPERAND (node, 2); + + case VAR_DECL: + if (! FIELD_STATIC (node) || ! FIELD_FINAL (node) + || DECL_INITIAL (node) == NULL_TREE) + return NULL_TREE; + val = DECL_INITIAL (node); + /* Guard against infinite recursion. */ + DECL_INITIAL (node) = NULL_TREE; + val = fold_constant_for_init (val, DECL_CONTEXT (node)); + DECL_INITIAL (node) = val; + return val; + + case EXPR_WITH_FILE_LOCATION: + /* Compare java_complete_tree and resolve_expression_name. */ + if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */ + || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE) + { + tree name = EXPR_WFL_NODE (node); + tree decl; + if (PRIMARY_P (node)) + return NULL_TREE; + else if (! QUALIFIED_P (name)) + { + decl = lookup_field_wrapper (DECL_CONTEXT (context), name); + if (! FIELD_STATIC (decl)) + return NULL_TREE; + return fold_constant_for_init (decl, decl); + } + else + { +#if 0 + /* Wait until the USE_COMPONENT_REF re-write. FIXME. */ + qualify_ambiguous_name (node); + if (resolve_field_access (node, &decl, NULL) + && decl != NULL_TREE) + return fold_constant_for_init (decl, decl); +#endif + return NULL_TREE; + } + } + else + { + op0 = TREE_OPERAND (node, 0); + val = fold_constant_for_init (op0, context); + if (val == NULL_TREE || ! TREE_CONSTANT (val)) + return NULL_TREE; + TREE_OPERAND (node, 0) = val; + return val; + } + +#ifdef USE_COMPONENT_REF + case IDENTIFIER: + case COMPONENT_REF: + ?; +#endif + + default: + return NULL_TREE; + } +} + +#ifdef USE_COMPONENT_REF +/* Context is 'T' for TypeName, 'P' for PackageName, + 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */ + +tree +resolve_simple_name (name, context) + tree name; + int context; +{ +} + +tree +resolve_qualified_name (name, context) + tree name; + int context; +{ +} +#endif |