diff options
| author | Per Bothner <bothner@gcc.gnu.org> | 1998-10-19 06:43:57 -0700 |
|---|---|---|
| committer | Per Bothner <bothner@gcc.gnu.org> | 1998-10-19 06:43:57 -0700 |
| commit | 8b27f2259691540a725b357cb52df670e324ca01 (patch) | |
| tree | fe000cc96d4e06a4b4061ebe39cdc9acf510bc92 /gcc | |
| parent | c20012b63373eacba50e92e918a48baf7f239054 (diff) | |
| download | gcc-8b27f2259691540a725b357cb52df670e324ca01.zip gcc-8b27f2259691540a725b357cb52df670e324ca01.tar.gz gcc-8b27f2259691540a725b357cb52df670e324ca01.tar.bz2 | |
�
Undo some mistakes from previous merge.
From-SVN: r23184
Diffstat (limited to 'gcc')
| -rw-r--r-- | gcc/java/parse.c | 11943 |
1 files changed, 11943 insertions, 0 deletions
diff --git a/gcc/java/parse.c b/gcc/java/parse.c new file mode 100644 index 0000000..9525681 --- /dev/null +++ b/gcc/java/parse.c @@ -0,0 +1,11943 @@ + +/* A Bison parser, made from parse.y + by GNU Bison version 1.25 + */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define yyparse java_parse +#define yylex java_lex +#define yyerror java_error +#define yylval java_lval +#define yychar java_char +#define yydebug java_debug +#define yynerrs java_nerrs +#define PLUS_TK 258 +#define MINUS_TK 259 +#define MULT_TK 260 +#define DIV_TK 261 +#define REM_TK 262 +#define LS_TK 263 +#define SRS_TK 264 +#define ZRS_TK 265 +#define AND_TK 266 +#define XOR_TK 267 +#define OR_TK 268 +#define BOOL_AND_TK 269 +#define BOOL_OR_TK 270 +#define EQ_TK 271 +#define NEQ_TK 272 +#define GT_TK 273 +#define GTE_TK 274 +#define LT_TK 275 +#define LTE_TK 276 +#define PLUS_ASSIGN_TK 277 +#define MINUS_ASSIGN_TK 278 +#define MULT_ASSIGN_TK 279 +#define DIV_ASSIGN_TK 280 +#define REM_ASSIGN_TK 281 +#define LS_ASSIGN_TK 282 +#define SRS_ASSIGN_TK 283 +#define ZRS_ASSIGN_TK 284 +#define AND_ASSIGN_TK 285 +#define XOR_ASSIGN_TK 286 +#define OR_ASSIGN_TK 287 +#define PUBLIC_TK 288 +#define PRIVATE_TK 289 +#define PROTECTED_TK 290 +#define STATIC_TK 291 +#define FINAL_TK 292 +#define SYNCHRONIZED_TK 293 +#define VOLATILE_TK 294 +#define TRANSIENT_TK 295 +#define NATIVE_TK 296 +#define PAD_TK 297 +#define ABSTRACT_TK 298 +#define MODIFIER_TK 299 +#define DECR_TK 300 +#define INCR_TK 301 +#define DEFAULT_TK 302 +#define IF_TK 303 +#define THROW_TK 304 +#define BOOLEAN_TK 305 +#define DO_TK 306 +#define IMPLEMENTS_TK 307 +#define THROWS_TK 308 +#define BREAK_TK 309 +#define IMPORT_TK 310 +#define ELSE_TK 311 +#define INSTANCEOF_TK 312 +#define RETURN_TK 313 +#define VOID_TK 314 +#define CATCH_TK 315 +#define INTERFACE_TK 316 +#define CASE_TK 317 +#define EXTENDS_TK 318 +#define FINALLY_TK 319 +#define SUPER_TK 320 +#define WHILE_TK 321 +#define CLASS_TK 322 +#define SWITCH_TK 323 +#define CONST_TK 324 +#define TRY_TK 325 +#define FOR_TK 326 +#define NEW_TK 327 +#define CONTINUE_TK 328 +#define GOTO_TK 329 +#define PACKAGE_TK 330 +#define THIS_TK 331 +#define BYTE_TK 332 +#define SHORT_TK 333 +#define INT_TK 334 +#define LONG_TK 335 +#define CHAR_TK 336 +#define INTEGRAL_TK 337 +#define FLOAT_TK 338 +#define DOUBLE_TK 339 +#define FP_TK 340 +#define ID_TK 341 +#define REL_QM_TK 342 +#define REL_CL_TK 343 +#define NOT_TK 344 +#define NEG_TK 345 +#define ASSIGN_ANY_TK 346 +#define ASSIGN_TK 347 +#define OP_TK 348 +#define CP_TK 349 +#define OCB_TK 350 +#define CCB_TK 351 +#define OSB_TK 352 +#define CSB_TK 353 +#define SC_TK 354 +#define C_TK 355 +#define DOT_TK 356 +#define STRING_LIT_TK 357 +#define CHAR_LIT_TK 358 +#define INT_LIT_TK 359 +#define FP_LIT_TK 360 +#define TRUE_TK 361 +#define FALSE_TK 362 +#define BOOL_LIT_TK 363 +#define NULL_TK 364 + +#line 49 "parse.y" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <dirent.h> +#ifdef __STDC__ +#include <stdarg.h> +#else +#include <varargs.h> +#endif + +#include "config.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" + +/* Number of error found so far. */ +int java_error_count; +/* Number of warning found so far. */ +int java_warning_count; + +/* The current parser context */ +static struct parser_ctxt *ctxp; + +/* 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 + once the type of both operator is worked out. */ + +static enum tree_code binop_lookup[19] = + { + PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR, + LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR, + BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR, + TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR, + EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR, + }; +#define BINOP_LOOKUP(VALUE) \ + binop_lookup [((VALUE) - PLUS_TK)% \ + (sizeof (binop_lookup) / sizeof (binop_lookup[0]))] + +/* 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; + +/* The "$L" identifier we use to create labels. */ +static tree label_id = NULL_TREE; + +/* The "StringBuffer" identifier used for the String `+' operator. */ +static tree wfl_string_buffer = NULL_TREE; + +/* 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; + +#line 114 "parse.y" +typedef union { + tree node; + int sub_token; + struct { + int token; + int location; + } operator; + int value; +} YYSTYPE; +#ifndef YYDEBUG +#define YYDEBUG 1 +#endif + +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 775 +#define YYFLAG -32768 +#define YYNTBASE 110 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 364 ? yytranslate[x] : 262) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, + 20, 22, 24, 26, 28, 30, 32, 34, 38, 42, + 46, 50, 54, 56, 58, 60, 64, 66, 67, 69, + 71, 73, 76, 79, 82, 86, 88, 91, 93, 96, + 100, 103, 107, 109, 111, 115, 118, 122, 128, 133, + 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, 801, 806, 809, 813, 819, 822, 826, 830, 835, + 837, 840, 843, 845, 847, 850, 854, 857, 860, 864, + 867, 872, 875, 878, 882, 887, 890, 892, 900, 908, + 915, 919, 925, 930, 938, 945, 948, 951, 955, 958, + 959, 961, 963, 966, 967, 969, 971, 975, 979, 982, + 986, 989, 993, 996, 1000, 1003, 1007, 1010, 1014, 1017, + 1021, 1025, 1028, 1032, 1038, 1044, 1047, 1052, 1056, 1058, + 1062, 1066, 1071, 1074, 1076, 1079, 1082, 1087, 1090, 1094, + 1099, 1102, 1105, 1107, 1109, 1111, 1113, 1117, 1119, 1121, + 1123, 1125, 1129, 1133, 1137, 1141, 1145, 1149, 1153, 1157, + 1163, 1168, 1175, 1181, 1186, 1192, 1198, 1205, 1209, 1213, + 1218, 1224, 1227, 1231, 1235, 1239, 1241, 1245, 1249, 1253, + 1257, 1262, 1267, 1272, 1277, 1281, 1285, 1287, 1290, 1294, + 1298, 1301, 1304, 1308, 1312, 1316, 1320, 1323, 1327, 1332, + 1338, 1345, 1351, 1358, 1363, 1368, 1373, 1378, 1382, 1387, + 1391, 1396, 1398, 1400, 1402, 1404, 1407, 1410, 1412, 1414, + 1417, 1420, 1422, 1425, 1428, 1431, 1434, 1437, 1440, 1442, + 1445, 1448, 1450, 1453, 1456, 1462, 1467, 1472, 1478, 1483, + 1486, 1492, 1497, 1503, 1505, 1509, 1513, 1517, 1521, 1525, + 1529, 1531, 1535, 1539, 1543, 1547, 1549, 1553, 1557, 1561, + 1565, 1569, 1573, 1575, 1579, 1583, 1587, 1591, 1595, 1599, + 1603, 1607, 1611, 1615, 1617, 1621, 1625, 1629, 1633, 1635, + 1639, 1643, 1645, 1649, 1653, 1655, 1659, 1663, 1665, 1669, + 1673, 1675, 1679, 1683, 1685, 1691, 1696, 1700, 1706, 1708, + 1710, 1714, 1718, 1720, 1722, 1724, 1726, 1728, 1730 +}; + +static const short yyrhs[] = { 123, + 0, 104, 0, 105, 0, 108, 0, 103, 0, 102, + 0, 109, 0, 113, 0, 114, 0, 82, 0, 85, + 0, 50, 0, 115, 0, 118, 0, 119, 0, 115, + 0, 115, 0, 113, 97, 98, 0, 119, 97, 98, + 0, 118, 97, 98, 0, 113, 97, 1, 0, 118, + 97, 1, 0, 120, 0, 121, 0, 122, 0, 119, + 101, 122, 0, 86, 0, 0, 126, 0, 124, 0, + 125, 0, 126, 124, 0, 126, 125, 0, 124, 125, + 0, 126, 124, 125, 0, 127, 0, 124, 127, 0, + 130, 0, 125, 130, 0, 75, 119, 99, 0, 75, + 1, 0, 75, 119, 1, 0, 128, 0, 129, 0, + 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, + 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, + 67, 122, 1, 0, 0, 63, 116, 0, 63, 116, + 1, 0, 63, 1, 0, 0, 52, 137, 0, 52, + 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, 260, 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, 229, 94, + 99, 0, 119, 101, 65, 93, 229, 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, 203, 0, 207, 0, 184, 0, + 188, 0, 193, 0, 204, 0, 208, 0, 176, 0, + 185, 0, 189, 0, 194, 0, 206, 0, 214, 0, + 215, 0, 216, 0, 218, 0, 217, 0, 220, 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, 229, 1, 0, + 162, 93, 229, 94, 1, 0, 119, 101, 65, 1, + 0, 119, 101, 65, 93, 1, 0, 119, 101, 65, + 93, 229, 1, 0, 119, 101, 65, 93, 229, 94, + 1, 0, 119, 101, 65, 93, 94, 1, 0, 257, + 0, 241, 0, 242, 0, 238, 0, 239, 0, 235, + 0, 227, 0, 48, 93, 260, 94, 182, 0, 48, + 1, 0, 48, 93, 1, 0, 48, 93, 260, 1, + 0, 48, 93, 260, 94, 183, 56, 182, 0, 48, + 93, 260, 94, 183, 56, 183, 0, 195, 196, 0, + 68, 93, 260, 94, 0, 68, 1, 0, 68, 93, + 1, 0, 68, 93, 260, 94, 1, 0, 95, 96, + 0, 95, 200, 96, 0, 95, 197, 96, 0, 95, + 197, 200, 96, 0, 198, 0, 197, 198, 0, 199, + 178, 0, 200, 0, 201, 0, 200, 201, 0, 62, + 261, 88, 0, 47, 88, 0, 62, 1, 0, 62, + 261, 1, 0, 47, 1, 0, 66, 93, 260, 94, + 0, 202, 182, 0, 66, 1, 0, 66, 93, 1, + 0, 66, 93, 260, 1, 0, 202, 183, 0, 51, + 0, 205, 182, 66, 93, 260, 94, 99, 0, 210, + 99, 260, 99, 212, 94, 182, 0, 210, 99, 99, + 212, 94, 182, 0, 210, 99, 1, 0, 210, 99, + 260, 99, 1, 0, 210, 99, 99, 1, 0, 210, + 99, 260, 99, 212, 94, 183, 0, 210, 99, 99, + 212, 94, 183, 0, 71, 93, 0, 71, 1, 0, + 71, 93, 1, 0, 209, 211, 0, 0, 213, 0, + 181, 0, 213, 1, 0, 0, 213, 0, 190, 0, + 213, 100, 190, 0, 213, 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, + 260, 99, 0, 58, 1, 0, 58, 260, 1, 0, + 49, 260, 99, 0, 49, 1, 0, 49, 260, 1, + 0, 219, 93, 260, 94, 176, 0, 219, 93, 260, + 94, 1, 0, 219, 1, 0, 219, 93, 1, 94, + 0, 219, 93, 1, 0, 44, 0, 70, 176, 221, + 0, 70, 176, 224, 0, 70, 176, 221, 224, 0, + 70, 1, 0, 222, 0, 221, 222, 0, 223, 176, + 0, 60, 93, 152, 94, 0, 60, 1, 0, 60, + 93, 1, 0, 60, 93, 1, 94, 0, 64, 176, + 0, 64, 1, 0, 226, 0, 230, 0, 111, 0, + 76, 0, 93, 260, 94, 0, 227, 0, 234, 0, + 235, 0, 236, 0, 119, 101, 67, 0, 113, 101, + 67, 0, 59, 101, 67, 0, 119, 101, 76, 0, + 93, 260, 1, 0, 119, 101, 1, 0, 113, 101, + 1, 0, 59, 101, 1, 0, 72, 116, 93, 229, + 94, 0, 72, 116, 93, 94, 0, 72, 116, 93, + 229, 94, 138, 0, 72, 116, 93, 94, 138, 0, + 228, 122, 93, 94, 0, 228, 122, 93, 94, 138, + 0, 228, 122, 93, 229, 94, 0, 228, 122, 93, + 229, 94, 138, 0, 72, 1, 99, 0, 72, 116, + 1, 0, 72, 116, 93, 1, 0, 72, 116, 93, + 229, 1, 0, 228, 1, 0, 228, 122, 1, 0, + 119, 101, 72, 0, 225, 101, 72, 0, 260, 0, + 229, 100, 260, 0, 229, 100, 1, 0, 72, 113, + 231, 0, 72, 115, 231, 0, 72, 113, 231, 233, + 0, 72, 115, 231, 233, 0, 72, 115, 233, 174, + 0, 72, 113, 233, 174, 0, 72, 1, 98, 0, + 72, 1, 97, 0, 232, 0, 231, 232, 0, 97, + 260, 98, 0, 97, 260, 1, 0, 97, 1, 0, + 97, 98, 0, 233, 97, 98, 0, 233, 97, 1, + 0, 225, 101, 122, 0, 65, 101, 122, 0, 65, + 1, 0, 119, 93, 94, 0, 119, 93, 229, 94, + 0, 225, 101, 122, 93, 94, 0, 225, 101, 122, + 93, 229, 94, 0, 65, 101, 122, 93, 94, 0, + 65, 101, 122, 93, 229, 94, 0, 65, 101, 1, + 94, 0, 65, 101, 1, 101, 0, 119, 97, 260, + 98, 0, 226, 97, 260, 98, 0, 119, 97, 1, + 0, 119, 97, 260, 1, 0, 226, 97, 1, 0, + 226, 97, 260, 1, 0, 225, 0, 119, 0, 238, + 0, 239, 0, 237, 46, 0, 237, 45, 0, 241, + 0, 242, 0, 3, 240, 0, 4, 240, 0, 243, + 0, 3, 1, 0, 4, 1, 0, 46, 240, 0, + 46, 1, 0, 45, 240, 0, 45, 1, 0, 237, + 0, 89, 240, 0, 90, 240, 0, 244, 0, 89, + 1, 0, 90, 1, 0, 93, 113, 233, 94, 240, + 0, 93, 113, 94, 240, 0, 93, 260, 94, 243, + 0, 93, 119, 233, 94, 243, 0, 93, 113, 97, + 1, 0, 93, 1, 0, 93, 113, 233, 94, 1, + 0, 93, 113, 94, 1, 0, 93, 119, 233, 94, + 1, 0, 240, 0, 245, 5, 240, 0, 245, 6, + 240, 0, 245, 7, 240, 0, 245, 5, 1, 0, + 245, 6, 1, 0, 245, 7, 1, 0, 245, 0, + 246, 3, 245, 0, 246, 4, 245, 0, 246, 3, + 1, 0, 246, 4, 1, 0, 246, 0, 247, 8, + 246, 0, 247, 9, 246, 0, 247, 10, 246, 0, + 247, 8, 1, 0, 247, 9, 1, 0, 247, 10, + 1, 0, 247, 0, 248, 20, 247, 0, 248, 18, + 247, 0, 248, 21, 247, 0, 248, 19, 247, 0, + 248, 57, 114, 0, 248, 20, 1, 0, 248, 18, + 1, 0, 248, 21, 1, 0, 248, 19, 1, 0, + 248, 57, 1, 0, 248, 0, 249, 16, 248, 0, + 249, 17, 248, 0, 249, 16, 1, 0, 249, 17, + 1, 0, 249, 0, 250, 11, 249, 0, 250, 11, + 1, 0, 250, 0, 251, 12, 250, 0, 251, 12, + 1, 0, 251, 0, 252, 13, 251, 0, 252, 13, + 1, 0, 252, 0, 253, 14, 252, 0, 253, 14, + 1, 0, 253, 0, 254, 15, 253, 0, 254, 15, + 1, 0, 254, 0, 254, 87, 260, 88, 255, 0, + 254, 87, 88, 1, 0, 254, 87, 1, 0, 254, + 87, 260, 88, 1, 0, 255, 0, 257, 0, 258, + 259, 256, 0, 258, 259, 1, 0, 119, 0, 234, + 0, 236, 0, 91, 0, 92, 0, 256, 0, 260, + 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 268, 274, 276, 277, 278, 279, 280, 284, 286, 289, + 291, 292, 295, 297, 300, 304, 308, 312, 318, 320, + 322, 324, 329, 331, 334, 338, 343, 348, 350, 351, + 352, 353, 354, 355, 356, 359, 364, 370, 372, 375, + 378, 380, 384, 386, 389, 419, 421, 425, 438, 440, + 444, 450, 451, 453, 463, 468, 483, 487, 490, 493, + 496, 498, 500, 502, 506, 508, 510, 512, 516, 518, + 520, 527, 533, 538, 542, 545, 549, 551, 554, 556, + 557, 558, 562, 564, 565, 567, 572, 575, 585, 588, + 590, 594, 597, 604, 610, 618, 620, 622, 624, 626, + 630, 632, 637, 644, 656, 660, 663, 665, 667, 669, + 671, 673, 675, 677, 684, 687, 689, 694, 696, 700, + 705, 710, 714, 719, 721, 723, 730, 732, 734, 738, + 741, 743, 747, 749, 750, 755, 760, 766, 778, 783, + 789, 794, 803, 805, 808, 810, 811, 812, 816, 818, + 821, 823, 827, 835, 846, 850, 853, 856, 859, 862, + 865, 868, 871, 873, 877, 883, 888, 890, 894, 897, + 901, 903, 906, 908, 909, 911, 915, 919, 925, 930, + 935, 939, 943, 949, 951, 952, 957, 960, 963, 970, + 972, 975, 977, 979, 983, 987, 990, 994, 996, 997, + 998, 999, 1000, 1010, 1012, 1013, 1014, 1015, 1018, 1020, + 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1032, + 1037, 1048, 1055, 1059, 1070, 1080, 1086, 1092, 1098, 1100, + 1102, 1104, 1106, 1108, 1110, 1112, 1114, 1118, 1120, 1121, + 1122, 1123, 1124, 1125, 1128, 1131, 1133, 1135, 1139, 1144, + 1149, 1157, 1163, 1165, 1167, 1171, 1174, 1176, 1178, 1187, + 1189, 1196, 1201, 1210, 1212, 1219, 1225, 1230, 1232, 1234, + 1238, 1246, 1249, 1251, 1253, 1257, 1262, 1271, 1276, 1279, + 1286, 1288, 1290, 1294, 1297, 1306, 1313, 1315, 1319, 1332, + 1334, 1340, 1346, 1350, 1352, 1356, 1359, 1361, 1365, 1368, + 1370, 1372, 1376, 1379, 1381, 1383, 1387, 1390, 1392, 1394, + 1398, 1404, 1406, 1410, 1417, 1419, 1421, 1423, 1427, 1435, + 1438, 1440, 1442, 1446, 1448, 1455, 1463, 1480, 1482, 1484, + 1488, 1494, 1499, 1501, 1504, 1506, 1508, 1510, 1511, 1512, + 1513, 1517, 1519, 1521, 1526, 1528, 1530, 1532, 1534, 1538, + 1541, 1546, 1548, 1553, 1554, 1555, 1556, 1557, 1559, 1561, + 1563, 1565, 1567, 1571, 1573, 1576, 1582, 1587, 1591, 1594, + 1596, 1598, 1602, 1604, 1606, 1608, 1612, 1615, 1619, 1625, + 1627, 1635, 1638, 1640, 1644, 1647, 1655, 1659, 1662, 1664, + 1669, 1674, 1683, 1696, 1698, 1702, 1705, 1707, 1712, 1717, + 1722, 1729, 1731, 1732, 1733, 1736, 1741, 1746, 1748, 1749, + 1751, 1753, 1754, 1756, 1760, 1763, 1767, 1770, 1774, 1776, + 1778, 1780, 1781, 1783, 1787, 1795, 1797, 1799, 1811, 1813, + 1819, 1821, 1823, 1827, 1829, 1834, 1839, 1844, 1846, 1848, + 1852, 1854, 1859, 1864, 1866, 1870, 1872, 1877, 1882, 1887, + 1889, 1891, 1895, 1897, 1902, 1907, 1912, 1917, 1918, 1920, + 1922, 1924, 1926, 1930, 1932, 1937, 1942, 1944, 1948, 1950, + 1955, 1959, 1961, 1966, 1970, 1972, 1977, 1981, 1983, 1988, + 1992, 1994, 1999, 2003, 2005, 2006, 2012, 2014, 2018, 2020, + 2023, 2026, 2034, 2036, 2037, 2040, 2042, 2045, 2049 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","PLUS_TK", +"MINUS_TK","MULT_TK","DIV_TK","REM_TK","LS_TK","SRS_TK","ZRS_TK","AND_TK","XOR_TK", +"OR_TK","BOOL_AND_TK","BOOL_OR_TK","EQ_TK","NEQ_TK","GT_TK","GTE_TK","LT_TK", +"LTE_TK","PLUS_ASSIGN_TK","MINUS_ASSIGN_TK","MULT_ASSIGN_TK","DIV_ASSIGN_TK", +"REM_ASSIGN_TK","LS_ASSIGN_TK","SRS_ASSIGN_TK","ZRS_ASSIGN_TK","AND_ASSIGN_TK", +"XOR_ASSIGN_TK","OR_ASSIGN_TK","PUBLIC_TK","PRIVATE_TK","PROTECTED_TK","STATIC_TK", +"FINAL_TK","SYNCHRONIZED_TK","VOLATILE_TK","TRANSIENT_TK","NATIVE_TK","PAD_TK", +"ABSTRACT_TK","MODIFIER_TK","DECR_TK","INCR_TK","DEFAULT_TK","IF_TK","THROW_TK", +"BOOLEAN_TK","DO_TK","IMPLEMENTS_TK","THROWS_TK","BREAK_TK","IMPORT_TK","ELSE_TK", +"INSTANCEOF_TK","RETURN_TK","VOID_TK","CATCH_TK","INTERFACE_TK","CASE_TK","EXTENDS_TK", +"FINALLY_TK","SUPER_TK","WHILE_TK","CLASS_TK","SWITCH_TK","CONST_TK","TRY_TK", +"FOR_TK","NEW_TK","CONTINUE_TK","GOTO_TK","PACKAGE_TK","THIS_TK","BYTE_TK","SHORT_TK", +"INT_TK","LONG_TK","CHAR_TK","INTEGRAL_TK","FLOAT_TK","DOUBLE_TK","FP_TK","ID_TK", +"REL_QM_TK","REL_CL_TK","NOT_TK","NEG_TK","ASSIGN_ANY_TK","ASSIGN_TK","OP_TK", +"CP_TK","OCB_TK","CCB_TK","OSB_TK","CSB_TK","SC_TK","C_TK","DOT_TK","STRING_LIT_TK", +"CHAR_LIT_TK","INT_LIT_TK","FP_LIT_TK","TRUE_TK","FALSE_TK","BOOL_LIT_TK","NULL_TK", +"goal","literal","type","primitive_type","reference_type","class_or_interface_type", +"class_type","interface_type","array_type","name","simple_name","qualified_name", +"identifier","compilation_unit","import_declarations","type_declarations","package_declaration", +"import_declaration","single_type_import_declaration","type_import_on_demand_declaration", +"type_declaration","modifiers","class_declaration","@1","@2","super","interfaces", +"interface_type_list","class_body","class_body_declarations","class_body_declaration", +"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", +"statement_expression","if_then_statement","if_then_else_statement","if_then_else_statement_nsi", +"switch_statement","switch_expression","switch_block","switch_block_statement_groups", +"switch_block_statement_group","group_of_labels","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 + +static const short yyr1[] = { 0, + 110, 111, 111, 111, 111, 111, 111, 112, 112, 113, + 113, 113, 114, 114, 115, 116, 117, 118, 118, 118, + 118, 118, 119, 119, 120, 121, 122, 123, 123, 123, + 123, 123, 123, 123, 123, 124, 124, 125, 125, 126, + 126, 126, 127, 127, 128, 128, 128, 129, 129, 129, + 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, 195, 195, 195, 195, 196, 196, 196, 196, 197, + 197, 198, 199, 200, 200, 201, 201, 201, 201, 201, + 202, 203, 203, 203, 203, 204, 205, 206, 207, 207, + 207, 207, 207, 208, 208, 209, 209, 209, 210, 211, + 211, 211, 211, 212, 212, 213, 213, 213, 214, 214, + 214, 214, 215, 215, 215, 215, 216, 216, 216, 216, + 217, 217, 217, 218, 218, 218, 218, 218, 219, 220, + 220, 220, 220, 221, 221, 222, 223, 223, 223, 223, + 224, 224, 225, 225, 226, 226, 226, 226, 226, 226, + 226, 226, 226, 226, 226, 226, 226, 226, 226, 227, + 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, + 227, 227, 227, 228, 228, 229, 229, 229, 230, 230, + 230, 230, 230, 230, 230, 230, 231, 231, 232, 232, + 232, 233, 233, 233, 234, 234, 234, 235, 235, 235, + 235, 235, 235, 235, 235, 236, 236, 236, 236, 236, + 236, 237, 237, 237, 237, 238, 239, 240, 240, 240, + 240, 240, 240, 240, 241, 241, 242, 242, 243, 243, + 243, 243, 243, 243, 244, 244, 244, 244, 244, 244, + 244, 244, 244, 245, 245, 245, 245, 245, 245, 245, + 246, 246, 246, 246, 246, 247, 247, 247, 247, 247, + 247, 247, 248, 248, 248, 248, 248, 248, 248, 248, + 248, 248, 248, 249, 249, 249, 249, 249, 250, 250, + 250, 251, 251, 251, 252, 252, 252, 253, 253, 253, + 254, 254, 254, 255, 255, 255, 255, 255, 256, 256, + 257, 257, 258, 258, 258, 259, 259, 260, 261 +}; + +static const short yyr2[] = { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, + 3, 3, 1, 1, 1, 3, 1, 0, 1, 1, + 1, 2, 2, 2, 3, 1, 2, 1, 2, 3, + 2, 3, 1, 1, 3, 2, 3, 5, 4, 5, + 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, 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, + 2, 4, 2, 3, 5, 2, 3, 3, 4, 1, + 2, 2, 1, 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, + 54, 55, 0, 0, 0, 0, 53, 1, 0, 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, 336, 0, 0, 0, + 0, 6, 5, 2, 3, 4, 7, 335, 0, 403, + 0, 102, 402, 333, 338, 0, 334, 339, 340, 341, + 419, 404, 405, 434, 408, 409, 412, 422, 441, 446, + 453, 464, 469, 472, 475, 478, 481, 484, 489, 498, + 490, 0, 101, 99, 97, 100, 109, 88, 108, 187, + 0, 0, 127, 76, 78, 105, 0, 136, 0, 125, + 123, 0, 116, 0, 0, 413, 403, 339, 341, 410, + 414, 411, 418, 417, 416, 415, 0, 387, 0, 0, + 0, 16, 0, 423, 420, 424, 421, 430, 0, 403, + 0, 180, 0, 184, 0, 0, 0, 0, 0, 95, + 0, 0, 362, 0, 407, 406, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 496, 497, 0, + 0, 55, 0, 0, 277, 0, 0, 0, 0, 0, + 0, 0, 0, 336, 0, 220, 0, 8, 403, 0, + 0, 194, 0, 209, 0, 190, 192, 0, 193, 198, + 210, 0, 199, 211, 0, 200, 201, 212, 0, 0, + 202, 0, 213, 203, 290, 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, 349, 344, 0, 386, + 376, 375, 358, 0, 369, 377, 0, 370, 0, 359, + 0, 0, 0, 0, 0, 0, 346, 337, 182, 181, + 0, 348, 343, 388, 0, 366, 398, 0, 347, 342, + 364, 345, 365, 385, 400, 0, 363, 0, 438, 435, + 439, 436, 440, 437, 444, 442, 445, 443, 450, 447, + 451, 448, 452, 449, 460, 455, 462, 457, 459, 454, + 461, 456, 463, 0, 458, 467, 465, 468, 466, 471, + 470, 474, 473, 477, 476, 480, 479, 483, 482, 487, + 0, 0, 492, 491, 227, 228, 226, 246, 0, 312, + 0, 301, 299, 0, 309, 307, 0, 273, 0, 253, + 0, 323, 0, 287, 0, 305, 303, 0, 0, 196, + 0, 0, 223, 221, 0, 0, 189, 191, 195, 319, + 403, 222, 225, 0, 251, 272, 0, 403, 0, 292, + 296, 289, 0, 0, 316, 0, 144, 140, 134, 145, + 403, 0, 0, 0, 141, 394, 395, 0, 381, 382, + 0, 378, 371, 0, 374, 372, 373, 360, 351, 0, + 432, 426, 429, 0, 0, 427, 186, 183, 185, 389, + 0, 399, 396, 0, 401, 397, 354, 0, 486, 0, + 247, 0, 313, 311, 302, 300, 310, 308, 274, 0, + 254, 0, 0, 0, 320, 324, 0, 321, 288, 306, + 304, 337, 0, 197, 229, 0, 0, 0, 0, 256, + 0, 260, 0, 263, 264, 0, 293, 0, 281, 0, + 0, 318, 0, 142, 0, 146, 0, 0, 147, 392, + 0, 380, 379, 384, 383, 353, 361, 350, 431, 425, + 433, 428, 368, 367, 390, 0, 355, 356, 488, 485, + 248, 0, 275, 271, 0, 328, 0, 332, 331, 325, + 322, 326, 233, 0, 230, 231, 0, 270, 267, 268, + 499, 0, 258, 261, 263, 0, 257, 265, 0, 298, + 297, 283, 0, 295, 0, 317, 0, 0, 148, 0, + 0, 393, 352, 391, 357, 0, 245, 0, 198, 0, + 205, 206, 0, 207, 208, 0, 255, 329, 0, 234, + 0, 0, 232, 269, 266, 259, 0, 0, 282, 0, + 315, 314, 0, 149, 0, 0, 0, 224, 276, 0, + 330, 327, 237, 235, 0, 0, 280, 0, 0, 0, + 150, 0, 249, 0, 0, 236, 278, 279, 152, 0, + 0, 0, 0, 151, 0, 0, 0, 0, 285, 0, + 250, 284, 0, 0, 0 +}; + +static const short yydefgoto[] = { 773, + 208, 347, 209, 85, 86, 68, 60, 87, 210, 22, + 23, 24, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 132, 105, 47, 70, 104, 130, 162, 163, + 164, 91, 114, 115, 116, 211, 166, 257, 92, 111, + 179, 180, 136, 183, 396, 168, 169, 170, 171, 400, + 552, 353, 18, 43, 72, 65, 107, 44, 63, 94, + 95, 96, 97, 212, 295, 354, 251, 355, 356, 357, + 358, 359, 708, 360, 361, 362, 363, 711, 364, 365, + 366, 367, 712, 368, 369, 535, 621, 622, 623, 624, + 625, 370, 371, 714, 372, 373, 374, 715, 375, 376, + 542, 693, 694, 377, 378, 379, 380, 381, 382, 383, + 605, 606, 607, 608, 213, 214, 215, 216, 435, 217, + 415, 416, 417, 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, 436, + 682 +}; + +static const short yypact[] = { 427, +-32768,-32768, 52, -22, 375, 386,-32768,-32768, 480, 591, + 675,-32768,-32768,-32768,-32768, 540,-32768,-32768,-32768,-32768, + 49,-32768,-32768,-32768, 206,-32768, 302,-32768, 70, 662, +-32768,-32768, 699, 748,-32768, -22, 389,-32768,-32768, 30, +-32768, 433, -57, 112,-32768, 435, 165,-32768,-32768, -22, + 829, 231,-32768, 370,-32768, 29,-32768,-32768,-32768,-32768, + 154, 1076,-32768, 439, -57,-32768,-32768, 275, 475,-32768, +-32768, -57, 112,-32768, 165,-32768,-32768,-32768, 488,-32768, +-32768,-32768, 511, 166,-32768,-32768, 175, -24, 866,-32768, +-32768, 111,-32768, 1109,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 224, 340,-32768, -57,-32768,-32768, 292, + -21,-32768, 355, 457,-32768, 629, -21, 51, 66, 344, +-32768, 536, 541,-32768,-32768,-32768,-32768, 561, 1013,-32768, +-32768, 340, 697, 569, 69,-32768,-32768,-32768, 593, 2179, + 74, 490,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -21, +-32768, 478, -21,-32768,-32768, 471, 477,-32768, 487, 866, +-32768, 1043,-32768,-32768,-32768,-32768, 78,-32768, 493,-32768, + 537,-32768,-32768,-32768,-32768,-32768, 598, 1186, -40,-32768, +-32768,-32768, 506,-32768,-32768,-32768, 516,-32768,-32768, 2926, + 2991, 3042, 3107, 520, 21, 483,-32768, 3158, 3223, 3274, + 5288,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 535, 923, + 18,-32768, 549, 557,-32768, 599,-32768, 534,-32768, 648, + 760,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 781, 837, + 808, 776, 833, 661, 670, 692, 702, 11,-32768,-32768, +-32768, 767,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 1906, 927, 537,-32768,-32768,-32768, 238, 619, 625,-32768, + 774, 601,-32768, 890, 608,-32768, 658,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, 35,-32768, 610, 747, + 635, 635, 287,-32768,-32768,-32768,-32768,-32768, 301, 1014, + 270,-32768, 639,-32768, 378, 222, 5355, 3339, 789,-32768, + 13, 3390,-32768, 327,-32768,-32768, 3455, 3506, 3571, 3622, + 3687, 3738, 3803, 3854, 3919, 3970, 4035, 4086, 595, 4151, + 4202, 4267, 4318, 4383, 4434, 4499, 2230,-32768,-32768, 4550, + 739, 339, 345, 4615,-32768, 143, 2295, 77, 357, 402, + 126, 407, 144, 644, 5587,-32768, -22, 409, 950, 462, + 1135,-32768, 651,-32768, 1554,-32768,-32768, 669,-32768,-32768, +-32768, 1974,-32768,-32768, 673,-32768,-32768,-32768, 689, 1974, +-32768, 1974,-32768,-32768, 1361, 677,-32768,-32768,-32768,-32768, +-32768, 412,-32768, 485, 656, 760, 834, 848,-32768,-32768, +-32768,-32768, 307, 625,-32768,-32768, 703,-32768, 1622, 713, +-32768, 774,-32768,-32768,-32768,-32768,-32768,-32768, 323, 706, +-32768,-32768,-32768, 2346, 635,-32768, 10, 635, 10,-32768, + 2411, 4666, 162, 266, 2462, 318,-32768, 5628,-32768,-32768, + 2114,-32768,-32768,-32768, 373,-32768,-32768, 200,-32768,-32768, +-32768,-32768,-32768, 721,-32768, 244,-32768, 5406,-32768,-32768, +-32768,-32768,-32768,-32768,-32768, 781,-32768, 781,-32768, 837, +-32768, 837,-32768, 837,-32768, 808,-32768, 808,-32768, 808, +-32768, 808,-32768, 166,-32768,-32768, 776,-32768, 776,-32768, + 833,-32768, 661,-32768, 670,-32768, 692,-32768, 702,-32768, + 825, 744,-32768,-32768,-32768,-32768,-32768,-32768, 4731,-32768, + 142,-32768,-32768, 145,-32768,-32768, 178,-32768, 4782,-32768, + 4847,-32768, 479,-32768, 5196,-32768,-32768, 180, 289, 753, + 2527, 584,-32768,-32768, -22, 2578,-32768,-32768,-32768,-32768, + 1122,-32768,-32768, 542,-32768,-32768, 800, 1030, 1186,-32768, +-32768,-32768, 24, 2643,-32768, 4898,-32768, 775,-32768,-32768, + 1063, 1702, 784, 1770,-32768,-32768,-32768, 5471,-32768,-32768, + 249,-32768, 785, 255,-32768, 785,-32768,-32768, 340, 82, +-32768,-32768,-32768, 4963, 1176,-32768,-32768,-32768,-32768,-32768, + 5014,-32768,-32768, 5522,-32768,-32768, 340, 481,-32768, 5079, +-32768, 290,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 294, +-32768, 790, 429, 139, 479,-32768, 493,-32768,-32768,-32768, +-32768,-32768, 430, 753,-32768, 897, 86, 212, 5130,-32768, + 650,-32768, 1906, 666,-32768, 810,-32768, 5330,-32768, 5221, + 806, 814, 820,-32768, 919,-32768, 1838, 2694,-32768,-32768, + 614,-32768,-32768,-32768,-32768,-32768,-32768, 340,-32768,-32768, +-32768,-32768,-32768,-32768,-32768, 681,-32768, 340,-32768,-32768, +-32768, 2040,-32768,-32768, 273,-32768, 918,-32768,-32768,-32768, +-32768,-32768,-32768, 2759,-32768,-32768, 917,-32768,-32768,-32768, +-32768, 274,-32768,-32768, 723, 1472,-32768,-32768, 5587,-32768, +-32768,-32768, 823, 821, 5263,-32768, 280, 445,-32768, 239, + 91,-32768,-32768,-32768,-32768, 459,-32768, 867, 868, 2040, +-32768,-32768, 2040,-32768,-32768, 827,-32768, 835, 842,-32768, + 936, 105,-32768,-32768,-32768,-32768, 844, 1974,-32768, 851, +-32768,-32768, 2810,-32768, 245, 4731, 1974,-32768,-32768, 2875, +-32768,-32768,-32768,-32768, 941, 850,-32768, 1974, 250, 199, +-32768, 295,-32768, 5221, 855,-32768,-32768,-32768,-32768, 252, + 2040, 853, 5263,-32768, 900, 2040, 863, 2040,-32768, 2040, +-32768,-32768, 961, 965,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768, -49, 6, 647, -13, -124, 309,-32768, -3, -66, +-32768, 115,-32768, 956, 700,-32768, 25,-32768,-32768, 623, + -25, -20,-32768,-32768, 915, 895,-32768, -130,-32768, 811, +-32768, -72, -119, 841, 442, -195,-32768,-32768, 281, -34, + 722, -263, -106,-32768,-32768,-32768,-32768,-32768, 828, 587, +-32768, 586, -48,-32768,-32768,-32768,-32768, 931, -10,-32768, + 899,-32768,-32768, 127,-32768, -121,-32768, -390, -350,-32768, + 621, -269, 288, -552,-32768, -502,-32768,-32768,-32768, -363, +-32768,-32768,-32768,-32768,-32768,-32768,-32768, 368,-32768, 387, + -603, -488,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -427, +-32768, -131, 624,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 405,-32768, 413,-32768,-32768, 94,-32768, -229,-32768, + 712, 8, -262, 1169, 141, 1189, 269, 316, 438, -175, + 560, 588, -421,-32768, 590, 574, 916, 592, 685, 696, + 698, 708, 701,-32768, 441, 695, 690,-32768,-32768, 84, +-32768 +}; + + +#define YYLAST 5737 + + +static const short yytable[] = { 21, + 404, 174, 29, 152, 528, 294, 576, 173, 554, 182, + 143, 541, 83, 93, 270, 272, 274, 276, 300, 419, + 688, 278, 285, 287, 627, 326, 424, 426, 59, 76, + 55, 134, 67, 31, 56, 407, 89, 62, 61, 123, + 173, 90, 61, 247, 83, 93, 249, 258, 117, 38, + 59, 144, 19, 263, 100, 59, 165, 31, 88, 264, + 61, 106, 159, 20, 259, 61, 146, 84, 89, 184, + 48, 283, 120, 90, 244, 135, 50, 278, 256, 83, + 172, 688, 647, 177, 443, 88, 676, 150, 153, 165, + 88, 676, 532, 159, 84, 159, 131, 327, 20, 84, + 536, 408, 537, 160, 201, 744, 564, 178, 161, 709, + 123, 124, 83, 172, 59, 20, -93, -93, 25, 27, + 67, 279, -291, 628, 61, 88, 512, 77, 262, 88, + 61, 450, 452, 454, 84, 397, 160, 20, 84, 668, + 406, 161, 593, 502, 516, 595, 394, 39, 145, 40, + 52, 54, 563, 652, 57, 566, 88, 709, 88, 710, + 709, 637, 573, 147, 57, 84, 185, 84, 49, -154, + 50, 245, -103, 713, 88, 648, -103, 279, 597, 677, + 610, 581, 282, 84, 735, 581, 267, 267, 267, 267, + 581, 570, 61, 110, 267, 267, 290, 113, 745, 744, + 582, 281, 177, 528, 581, 289, 41, 710, 709, 125, + 710, 64, 678, 709, 177, 709, 69, 709, 588, 513, + 157, 713, 432, 243, 713, 351, 178, 520, 20, 20, + 352, 71, 686, 157, 716, 579, 110, 113, 178, 675, + 594, 503, 517, 596, 585, 723, 572, 349, 88, 642, + 743, 67, 756, 187, 50, 644, 348, 84, 710, 560, + 88, 61, 118, 710, 691, 710, 541, 710, 42, 84, + 427, 119, 713, 717, 724, 101, 598, 713, 611, 713, + 731, 713, 716, 291, 243, 716, 528, 420, 433, 427, + 661, 187, 760, 42, 663, 661, 617, 583, 581, 679, + -155, 525, 45, 267, 267, 267, 267, 267, 267, 267, + 267, 267, 267, 267, 267, 88, 267, 267, 267, 267, + 267, 267, 267, 128, 474, -157, -66, 447, 641, 351, + 304, 541, 157, 716, 352, 528, 395, 734, 716, -319, + 716, 586, 716, 751, 384, 498, 643, 88, 759, 539, + 764, 349, 645, -65, 656, 137, 84, 508, 531, 574, + 348, 725, 564, 428, 46, 350, 531, -252, 531, -66, + 74, 538, 99, 351, 157, 26, 187, 103, 352, 421, + 348, 438, 612, 662, 133, 446, 28, 664, 761, 53, + 541, 385, 707, 410, 422, 551, -65, 423, 650, 541, + 547, 296, 510, 719, 348, 614, 264, 514, 701, 167, + 492, 575, 545, 57, 564, 444, 556, 501, 267, 448, + 507, -65, 562, 557, 267, 562, -28, 1, 519, 666, + 673, -319, 46, 58, 129, 66, 155, 499, 646, 98, + 532, 148, 167, 536, 722, 673, -96, 133, 384, 509, + 504, -96, -96, -96, -96, 384, 657, 518, 747, 498, + 20, 187, 523, 384, -65, 384, 580, 753, 384, 350, + 2, 20, 581, 430, 20, 102, 350, 431, 758, -30, + 1, 3, 669, 280, 350, 672, 350, 4, 109, 525, + 246, 707, 384, 5, 511, 385, 747, 561, 753, 515, + 758, 6, 385, 750, 546, 118, -25, -25, 438, 296, + 385, 112, 385, 350, 243, 385, 137, 703, 20, 386, + 20, 667, 674, 2, 20, 7, 351, 705, 351, -338, + -338, 352, 78, 352, 3, 88, 149, 733, 603, 385, + 4, 151, 604, 565, 84, 567, 5, -25, 349, 524, + 349, 736, -25, -25, -25, 138, 139, 348, -25, 348, + 20, 154, -25, 730, 80, -138, 387, 81, 20, 181, + 267, 267, 250, 20, 658, 732, 248, 139, 7, 252, + 581, -338, 592, 35, 439, -338, 267, 157, 618, 134, + -31, 1, 600, 186, 602, 473, 20, 351, 260, 303, + 36, 401, 352, 619, 438, 265, 37, -96, 405, -96, + 409, 351, -96, -96, -96, -96, 352, 177, 261, 349, + 277, 20, 762, 386, -494, -494, 20, 631, 348, 633, + 386, 767, 32, 349, 2, 296, 57, 620, 386, 187, + 386, 178, 348, 386, 78, 384, 20, 384, 613, 301, + 440, 4, 32, 302, 20, 441, 32, 5, 531, 442, + 351, -34, 1, 88, 654, 352, 350, 386, 350, 20, + 387, 322, 84, 32, -29, 1, 80, 387, 20, 81, + 20, 323, 349, 20, 20, 387, 20, 387, 388, 7, + 387, 348, 385, 20, 385, 20, 618, 175, -32, 1, + -340, -340, 681, 402, 324, 2, 531, 702, 30, 531, + 34, 619, 618, 581, 387, 325, 384, 398, 2, 399, + 140, 384, 4, 384, 531, 141, 142, 619, 5, 3, + 384, 414, 51, 531, 429, 4, -153, 350, -495, -495, + 2, 5, 2, 526, 531, 683, 78, -33, 1, 57, + 297, 350, -340, 3, 298, 384, -340, 531, 299, 4, + 7, 687, 531, 385, 531, 5, 531, 529, 385, 618, + 385, 533, 727, 7, 704, 544, 350, 385, 80, 384, + 581, 81, 20, 534, 619, 307, 308, 309, 384, 439, + 176, 2, 388, 315, 316, 317, 318, 7, 558, 388, + 350, 549, 385, 384, 305, 306, 384, 388, 4, 388, + 389, 555, 388, 584, 5, 312, 313, 314, 726, 752, + 386, 384, 386, 755, 350, 589, 385, 350, -35, 1, + 384, 590, 319, 495, 496, 385, 388, 497, 390, 310, + 311, 384, 350, 411, 412, 413, 7, 384, 320, 321, + 385, 350, 139, 385, 384, 440, 384, 328, 329, 384, + 441, 384, 350, 384, 442, 626, 121, 387, 385, 387, + 141, 142, 2, 634, 20, 350, 638, 385, -404, -404, + 350, 564, 350, 665, 350, 460, 462, 464, 385, 4, + 403, 386, -405, -405, 385, 5, 386, 675, 386, 456, + 458, 385, 689, 385, 695, 386, 385, 696, 385, 35, + 385, 477, 479, 697, 389, 78, 728, 723, 718, 439, + 628, 389, 737, -204, 122, 740, 36, 7, 741, 389, + 386, 389, 37, 2, 389, 742, 743, 746, 387, 78, + 391, 756, 390, 387, 748, 387, 766, 80, 757, 390, + 81, 20, 387, 763, 386, 768, 770, 390, 389, 390, + 774, 2, 390, 386, 775, 475, 33, 78, 75, 108, + 2, 80, 255, 393, 81, 20, 78, 387, 386, 188, + 548, 386, 73, 698, 553, 440, 390, 253, 684, 388, + 441, 388, 127, 418, 442, 540, 386, 738, 543, 80, + 739, 387, 81, 20, 20, 386, 481, 685, 80, 670, + 387, 81, 20, -493, -493, 297, 386, 671, 483, 298, + 392, 485, 386, 299, 494, 387, 489, 0, 387, 386, + 660, 386, 487, 0, 386, -15, 386, 0, 386, 0, + -493, -493, 297, 387, 391, 0, 521, 0, 765, 0, + 522, 391, 387, 769, 0, 771, 156, 772, 0, 391, + 388, 391, 78, 387, 391, 388, 0, 388, 0, 387, + 0, 79, 0, 4, 388, 0, 387, 0, 387, 5, + 0, 387, 0, 387, 0, 387, 156, 0, 391, 0, + 0, 0, 78, 0, 80, 0, 0, 81, 20, 388, + 0, 79, 0, 4, -493, -493, 297, 157, 158, 5, + 425, 389, 0, 389, 299, -15, 0, 0, 0, 2, + -493, -493, 297, 388, 80, 78, 521, 81, 20, 0, + 299, 0, 388, 0, 79, 0, 4, 157, 254, 390, + 0, 390, 5, 0, 0, 0, 0, 388, -15, 0, + 388, 0, 2, -493, -493, 297, 0, 80, 78, 521, + 81, 20, 0, 635, 0, 388, 0, 79, 0, 4, + 0, 82, 0, 0, 388, 5, 651, 0, 35, 0, + 0, 0, 389, 0, 78, 388, 0, 389, 0, 389, + 80, 388, 0, 81, 20, 0, 389, 0, 388, 0, + 388, 37, 0, 388, 126, 388, 0, 388, 0, 0, + 390, 0, -493, -493, 297, 390, 80, 390, 298, 81, + 20, 389, 522, 0, 390, 78, 0, 0, 0, 35, + 466, 468, 470, 472, 194, 78, 0, 0, 0, 0, + 195, 391, 0, 391, 0, 389, 0, 196, 0, 390, + 0, 197, 0, 0, 389, 0, 0, 80, 0, 0, + 81, 20, 0, 0, 198, 199, 0, 80, 200, 389, + 81, 20, 389, 390, 0, 0, 0, 202, 203, 204, + 205, 0, 390, 206, 207, 0, 0, 389, 0, 0, + 0, 0, 0, 0, 0, 0, 389, 390, 0, 0, + 390, 0, 0, 0, 0, 0, 0, 389, 0, 0, + 0, 0, 391, 389, 0, 390, 0, 391, 0, 391, + 389, 0, 389, 0, 390, 389, 391, 389, 0, 389, + 0, 0, 0, 0, 0, 390, 0, 0, 0, 0, + 0, 390, 0, 0, 0, 0, 0, 0, 390, 0, + 390, 391, 0, 390, 0, 390, 0, 390, 268, 268, + 268, 268, 0, 0, 0, 0, 268, 268, 0, 0, + 0, 0, 0, 0, 0, 391, 0, 0, 269, 269, + 269, 269, 0, 0, 391, 0, 269, 269, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 391, + 0, 0, 391, 0, 2, 192, 193, 0, 0, 0, + 78, 0, 0, 0, 0, 0, 0, 391, 0, 194, + 0, 0, 0, 0, 0, 195, 391, 0, 0, 0, + 0, 0, 196, 0, 0, 0, 197, 391, 0, 0, + 0, 0, 80, 391, 0, 81, 20, 0, 0, 0, + 391, 0, 391, 345, 0, 391, 0, 391, 0, 391, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 0, 0, 331, 0, 0, 268, 268, 268, 268, 268, + 268, 268, 268, 268, 268, 268, 268, 0, 268, 268, + 268, 268, 268, 268, 268, 269, 269, 269, 269, 269, + 269, 269, 269, 269, 269, 269, 269, 0, 269, 269, + 269, 269, 269, 269, 269, 332, 192, 193, -262, 333, + 334, 78, 335, 0, 0, 336, 0, 0, 0, 337, + 194, 0, 0, -262, 0, 0, 338, 339, 5, 340, + 0, 341, 342, 196, 343, 0, 0, 344, 0, 0, + 0, 0, 0, 80, 331, 0, 81, 20, 0, 0, + 0, 0, 0, 0, 345, 0, 157, -262, 0, 0, + 346, 0, 0, 202, 203, 204, 205, 0, 0, 206, + 207, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 268, 0, 0, 0, 0, 0, 268, 332, 192, 193, + 0, 333, 334, 78, 335, 0, 0, 336, 0, 0, + 269, 337, 194, 0, 0, 0, 269, 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, 527, + 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, + 0, 341, 342, 196, 343, 0, 0, 344, 0, 0, + 0, 0, 331, 80, 0, 0, 81, 20, 0, 0, + 0, 0, 0, 0, 345, 0, 157, 550, 0, 0, + 346, 0, 0, 202, 203, 204, 205, 0, 0, 206, + 207, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 268, 268, 0, 332, 192, 193, 0, 333, + 334, 78, 335, 0, 0, 336, 0, 0, 268, 337, + 194, 0, 269, 269, 0, 0, 338, 339, 5, 340, + 331, 341, 342, 196, 343, 0, 0, 344, 269, 0, + 0, 0, 0, 80, 0, 0, 81, 20, 0, 0, + 0, 0, 0, 0, 345, 0, 157, 636, 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, 639, 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, 699, 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, 530, 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, 530, 192, 193, 0, 706, 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, 577, 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, 0, 0, 0, 0, 0, + 0, 0, 194, 0, 0, 0, 0, 0, 195, 189, + 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, 201, 578, + 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, + 490, 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, 201, 192, 193, 0, 0, 0, 78, + 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, + 0, 0, 0, 0, 195, 505, 0, 190, 191, 0, + 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 491, 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, 559, 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, 506, 0, 78, 202, 203, 204, 205, + 0, 0, 206, 207, 194, 0, 0, 0, 0, 0, + 195, 568, 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, 560, 0, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 192, 193, 0, 0, 0, + 78, 0, 437, 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, 569, 0, 192, 193, 0, 0, + 0, 78, 202, 203, 204, 205, 0, 0, 206, 207, + 194, 0, 0, 0, 0, 0, 195, 437, 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, 560, + 0, 0, 0, 202, 203, 204, 205, 0, 0, 206, + 207, 192, 193, 0, 0, 0, 78, 0, 615, 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, 629, 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, 616, 0, 0, 0, 0, 0, 0, 0, 202, + 203, 204, 205, 0, 0, 206, 207, 192, 193, 0, + 0, 0, 78, 0, 615, 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, 630, 0, 78, 202, 203, 204, 205, 0, 0, + 206, 207, 194, 0, 0, 0, 0, 0, 195, 720, + 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, 700, 0, 0, + 0, 0, 0, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 192, 193, 0, 0, 0, 78, 0, + 720, 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, 721, 0, 192, 193, 0, 0, 0, 78, + 202, 203, 204, 205, 0, 0, 206, 207, 194, 0, + 0, 0, 0, 0, 195, 629, 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, 749, 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, 754, 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, 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, 437, + 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, + 445, 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, 449, 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, 451, 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, 453, 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, 455, 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, 457, 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, 459, 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, 461, 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, 463, 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, 465, + 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, + 467, 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, 469, 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, 471, 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, 476, 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, 478, 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, 480, 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, 482, 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, 484, 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, 486, 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, 488, + 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, + 493, 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, 500, 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, 571, 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, 591, 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, 599, 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, 601, 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, 632, 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, 649, 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, 653, 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, 659, + 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, + 680, 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, 0, 609, 0, 0, 0, + 0, 196, 0, 0, 0, 197, 0, 0, 0, 0, + 0, 80, 0, 0, 81, 20, 0, 0, 198, 199, + 0, 692, 200, 0, 0, 0, 0, 0, 0, 0, + 0, 202, 203, 204, 205, 0, 0, 206, 207, -286, + -286, -286, 0, 0, 0, -286, 0, 0, 0, 0, + 0, 0, 0, 0, -286, 0, 0, 0, 0, 0, + -286, 0, 0, 729, 0, 192, 193, -286, 0, 0, + 78, -286, 0, 0, 0, 0, 0, -286, 0, 194, + -286, -286, 0, 0, 0, 195, 0, 0, -286, 0, + 190, 191, 196, 0, -286, 0, 197, -286, -286, -286, + -286, 0, 80, -286, -286, 81, 20, 192, 193, 0, + 0, 0, 78, 345, -294, 0, 0, 0, 0, 0, + 0, 194, 202, 203, 204, 205, 0, 195, 206, 207, + 690, 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, -294, 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, 434, 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, 587, + 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, 640, 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, 655, 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, 78, 0, 200, + 0, 0, 0, 0, 0, 0, 194, 0, 202, 203, + 204, 205, 195, 0, 206, 207, 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, 0, 0, 0, 0, 0, 0, 202, + 203, 204, 205, 0, 0, 206, 207 +}; + +static const short yycheck[] = { 3, + 264, 132, 6, 123, 355, 201, 428, 129, 399, 134, + 117, 375, 62, 62, 190, 191, 192, 193, 1, 282, + 624, 1, 198, 199, 1, 15, 289, 290, 42, 1, + 1, 53, 46, 9, 5, 1, 62, 95, 42, 89, + 162, 62, 46, 150, 94, 94, 153, 169, 83, 1, + 64, 1, 1, 94, 65, 69, 129, 33, 62, 100, + 64, 72, 129, 86, 171, 69, 1, 62, 94, 1, + 1, 196, 97, 94, 1, 97, 101, 1, 1, 129, + 129, 685, 1, 133, 72, 89, 1, 122, 123, 162, + 94, 1, 362, 160, 89, 162, 107, 87, 86, 94, + 370, 67, 372, 129, 95, 1, 97, 133, 129, 662, + 160, 1, 162, 162, 128, 86, 99, 100, 4, 5, + 134, 101, 99, 100, 128, 129, 1, 99, 178, 133, + 134, 307, 308, 309, 129, 257, 162, 86, 133, 1, + 265, 162, 1, 1, 1, 1, 253, 99, 98, 101, + 36, 37, 415, 575, 40, 418, 160, 710, 162, 662, + 713, 552, 1, 98, 50, 160, 98, 162, 99, 93, + 101, 98, 95, 662, 178, 94, 99, 101, 1, 94, + 1, 100, 196, 178, 94, 100, 190, 191, 192, 193, + 100, 421, 196, 79, 198, 199, 200, 83, 94, 1, + 1, 196, 252, 554, 100, 200, 1, 710, 761, 99, + 713, 100, 1, 766, 264, 768, 52, 770, 448, 341, + 95, 710, 1, 140, 713, 251, 252, 347, 86, 86, + 251, 1, 623, 95, 662, 431, 122, 123, 264, 1, + 99, 99, 99, 99, 1, 1, 422, 251, 252, 1, + 1, 265, 1, 139, 101, 1, 251, 252, 761, 98, + 264, 265, 97, 766, 628, 768, 630, 770, 63, 264, + 1, 97, 761, 1, 1, 1, 99, 766, 99, 768, + 1, 770, 710, 200, 201, 713, 637, 1, 67, 1, + 1, 177, 94, 63, 1, 1, 526, 98, 100, 88, + 95, 351, 1, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 100, 319, 95, 52, 1, 558, 355, + 216, 695, 95, 761, 355, 686, 99, 99, 766, 1, + 768, 98, 770, 99, 251, 1, 98, 351, 99, 375, + 99, 355, 98, 52, 584, 1, 351, 1, 362, 94, + 355, 88, 97, 94, 63, 251, 370, 95, 372, 95, + 1, 375, 64, 399, 95, 1, 262, 69, 399, 93, + 375, 298, 94, 94, 93, 302, 1, 94, 94, 1, + 754, 251, 662, 279, 94, 399, 95, 97, 574, 763, + 94, 101, 1, 667, 399, 525, 100, 1, 638, 129, + 327, 94, 1, 299, 97, 301, 94, 334, 422, 93, + 337, 52, 415, 101, 428, 418, 0, 1, 345, 1, + 1, 93, 63, 1, 95, 1, 128, 93, 569, 1, + 710, 98, 162, 713, 674, 1, 92, 93, 355, 93, + 336, 97, 98, 99, 100, 362, 587, 343, 728, 1, + 86, 347, 1, 370, 95, 372, 94, 737, 375, 355, + 44, 86, 100, 96, 86, 1, 362, 100, 748, 0, + 1, 55, 604, 1, 370, 607, 372, 61, 1, 539, + 1, 761, 399, 67, 93, 355, 766, 414, 768, 93, + 770, 75, 362, 733, 93, 97, 45, 46, 425, 101, + 370, 1, 372, 399, 431, 375, 1, 648, 86, 251, + 86, 93, 93, 44, 86, 99, 552, 658, 554, 45, + 46, 552, 50, 554, 55, 539, 1, 93, 60, 399, + 61, 1, 64, 417, 539, 419, 67, 86, 552, 88, + 554, 93, 91, 92, 93, 99, 100, 552, 97, 554, + 86, 1, 101, 695, 82, 95, 251, 85, 86, 1, + 574, 575, 96, 86, 94, 697, 99, 100, 99, 93, + 100, 97, 499, 44, 1, 101, 590, 95, 47, 53, + 0, 1, 509, 1, 511, 1, 86, 623, 1, 1, + 61, 1, 623, 62, 521, 100, 67, 92, 1, 94, + 1, 637, 97, 98, 99, 100, 637, 667, 177, 623, + 101, 86, 754, 355, 91, 92, 86, 544, 623, 546, + 362, 763, 10, 637, 44, 101, 522, 96, 370, 525, + 372, 667, 637, 375, 50, 552, 86, 554, 65, 101, + 67, 61, 30, 97, 86, 72, 34, 67, 662, 76, + 686, 0, 1, 667, 581, 686, 552, 399, 554, 86, + 355, 11, 667, 51, 0, 1, 82, 362, 86, 85, + 86, 12, 686, 86, 86, 370, 86, 372, 251, 99, + 375, 686, 552, 86, 554, 86, 47, 1, 0, 1, + 45, 46, 619, 262, 13, 44, 710, 94, 9, 713, + 11, 62, 47, 100, 399, 14, 623, 99, 44, 95, + 92, 628, 61, 630, 728, 97, 98, 62, 67, 55, + 637, 97, 33, 737, 96, 61, 93, 623, 91, 92, + 44, 67, 44, 93, 748, 96, 50, 0, 1, 635, + 93, 637, 97, 55, 97, 662, 101, 761, 101, 61, + 99, 96, 766, 623, 768, 67, 770, 99, 628, 47, + 630, 99, 689, 99, 94, 99, 662, 637, 82, 686, + 100, 85, 86, 95, 62, 5, 6, 7, 695, 1, + 94, 44, 355, 18, 19, 20, 21, 99, 93, 362, + 686, 99, 662, 710, 45, 46, 713, 370, 61, 372, + 251, 99, 375, 93, 67, 8, 9, 10, 96, 736, + 552, 728, 554, 740, 710, 1, 686, 713, 0, 1, + 737, 88, 57, 95, 96, 695, 399, 99, 251, 3, + 4, 748, 728, 97, 98, 99, 99, 754, 16, 17, + 710, 737, 100, 713, 761, 67, 763, 91, 92, 766, + 72, 768, 748, 770, 76, 66, 1, 552, 728, 554, + 97, 98, 44, 99, 86, 761, 93, 737, 45, 46, + 766, 97, 768, 94, 770, 312, 313, 314, 748, 61, + 1, 623, 45, 46, 754, 67, 628, 1, 630, 310, + 311, 761, 93, 763, 99, 637, 766, 94, 768, 44, + 770, 320, 321, 94, 355, 50, 94, 1, 1, 1, + 100, 362, 56, 56, 59, 99, 61, 99, 94, 370, + 662, 372, 67, 44, 375, 94, 1, 94, 623, 50, + 251, 1, 355, 628, 94, 630, 94, 82, 99, 362, + 85, 86, 637, 99, 686, 56, 94, 370, 399, 372, + 0, 44, 375, 695, 0, 319, 11, 50, 54, 75, + 44, 82, 162, 252, 85, 86, 50, 662, 710, 139, + 394, 713, 52, 65, 399, 67, 399, 160, 621, 552, + 72, 554, 94, 282, 76, 375, 728, 710, 375, 82, + 713, 686, 85, 86, 86, 737, 322, 621, 82, 605, + 695, 85, 86, 91, 92, 93, 748, 605, 323, 97, + 94, 324, 754, 101, 330, 710, 326, -1, 713, 761, + 590, 763, 325, -1, 766, 86, 768, -1, 770, -1, + 91, 92, 93, 728, 355, -1, 97, -1, 761, -1, + 101, 362, 737, 766, -1, 768, 44, 770, -1, 370, + 623, 372, 50, 748, 375, 628, -1, 630, -1, 754, + -1, 59, -1, 61, 637, -1, 761, -1, 763, 67, + -1, 766, -1, 768, -1, 770, 44, -1, 399, -1, + -1, -1, 50, -1, 82, -1, -1, 85, 86, 662, + -1, 59, -1, 61, 91, 92, 93, 95, 96, 67, + 97, 552, -1, 554, 101, 86, -1, -1, -1, 44, + 91, 92, 93, 686, 82, 50, 97, 85, 86, -1, + 101, -1, 695, -1, 59, -1, 61, 95, 96, 552, + -1, 554, 67, -1, -1, -1, -1, 710, 86, -1, + 713, -1, 44, 91, 92, 93, -1, 82, 50, 97, + 85, 86, -1, 101, -1, 728, -1, 59, -1, 61, + -1, 96, -1, -1, 737, 67, 1, -1, 44, -1, + -1, -1, 623, -1, 50, 748, -1, 628, -1, 630, + 82, 754, -1, 85, 86, -1, 637, -1, 761, -1, + 763, 67, -1, 766, 96, 768, -1, 770, -1, -1, + 623, -1, 91, 92, 93, 628, 82, 630, 97, 85, + 86, 662, 101, -1, 637, 50, -1, -1, -1, 44, + 315, 316, 317, 318, 59, 50, -1, -1, -1, -1, + 65, 552, -1, 554, -1, 686, -1, 72, -1, 662, + -1, 76, -1, -1, 695, -1, -1, 82, -1, -1, + 85, 86, -1, -1, 89, 90, -1, 82, 93, 710, + 85, 86, 713, 686, -1, -1, -1, 102, 103, 104, + 105, -1, 695, 108, 109, -1, -1, 728, -1, -1, + -1, -1, -1, -1, -1, -1, 737, 710, -1, -1, + 713, -1, -1, -1, -1, -1, -1, 748, -1, -1, + -1, -1, 623, 754, -1, 728, -1, 628, -1, 630, + 761, -1, 763, -1, 737, 766, 637, 768, -1, 770, + -1, -1, -1, -1, -1, 748, -1, -1, -1, -1, + -1, 754, -1, -1, -1, -1, -1, -1, 761, -1, + 763, 662, -1, 766, -1, 768, -1, 770, 190, 191, + 192, 193, -1, -1, -1, -1, 198, 199, -1, -1, + -1, -1, -1, -1, -1, 686, -1, -1, 190, 191, + 192, 193, -1, -1, 695, -1, 198, 199, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 710, + -1, -1, 713, -1, 44, 45, 46, -1, -1, -1, + 50, -1, -1, -1, -1, -1, -1, 728, -1, 59, + -1, -1, -1, -1, -1, 65, 737, -1, -1, -1, + -1, -1, 72, -1, -1, -1, 76, 748, -1, -1, + -1, -1, 82, 754, -1, 85, 86, -1, -1, -1, + 761, -1, 763, 93, -1, 766, -1, 768, -1, 770, + -1, -1, 102, 103, 104, 105, -1, -1, 108, 109, + -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, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, -1, 320, 321, + 322, 323, 324, 325, 326, 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, -1, -1, -1, -1, -1, -1, -1, + 422, -1, -1, -1, -1, -1, 428, 44, 45, 46, + -1, 48, 49, 50, 51, -1, -1, 54, -1, -1, + 422, 58, 59, -1, -1, -1, 428, -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, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 574, 575, -1, 44, 45, 46, -1, 48, + 49, 50, 51, -1, -1, 54, -1, -1, 590, 58, + 59, -1, 574, 575, -1, -1, 65, 66, 67, 68, + 1, 70, 71, 72, 73, -1, -1, 76, 590, -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, -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, 95, 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, 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, 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, -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, 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, 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, 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, -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, -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, 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, -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, -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, + -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, -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, -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, -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, -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, -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, -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, -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, -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, -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, + -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, -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, -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, -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, -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, -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, -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, -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, -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, -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, + -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, -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, -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, -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, -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, -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, -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, -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, -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, -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, + -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, -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, -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, -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, -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, -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, 89, 90, + -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, 50, -1, 93, + -1, -1, -1, -1, -1, -1, 59, -1, 102, 103, + 104, 105, 65, -1, 108, 109, -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, 102, + 103, 104, 105, -1, -1, 108, 109 +}; +#define YYPURE 1 + +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "bison.simple" + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef alloca +#ifdef __GNUC__ +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) +#include <alloca.h> +#else /* not sparc */ +#if defined (MSDOS) && !defined (__TURBOC__) +#include <malloc.h> +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +#include <malloc.h> + #pragma alloca +#else /* not MSDOS, __TURBOC__, or _AIX */ +#ifdef __hpux +#ifdef __cplusplus +extern "C" { +void *alloca (unsigned int); +}; +#else /* not __cplusplus */ +void *alloca (); +#endif /* not __cplusplus */ +#endif /* __hpux */ +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc. */ +#endif /* not GNU C. */ +#endif /* alloca not defined. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT return(0) +#define YYABORT return(1) +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +int yyparse (void); +#endif + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, int count) +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 196 "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 *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + yyss = (short *) alloca (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp)); + yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 1: +#line 270 "parse.y" +{; + break;} +case 18: +#line 314 "parse.y" +{ + yyval.node = build_java_array_type (yyvsp[-2].node, -1); + CLASS_LOADED_P (yyval.node) = 1; + ; + break;} +case 19: +#line 319 "parse.y" +{ yyval.node = build_unresolved_array_type (yyvsp[-2].node); ; + break;} +case 20: +#line 321 "parse.y" +{ yyval.node = build_unresolved_array_type (yyvsp[-2].node); ; + break;} +case 21: +#line 323 "parse.y" +{RULE ("']' expected"); RECOVER;; + break;} +case 22: +#line 325 "parse.y" +{RULE ("']' expected"); RECOVER;; + break;} +case 26: +#line 340 "parse.y" +{ yyval.node = make_qualified_name (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); ; + break;} +case 28: +#line 349 "parse.y" +{yyval.node = NULL;; + break;} +case 36: +#line 361 "parse.y" +{ + yyval.node = NULL; + ; + break;} +case 37: +#line 365 "parse.y" +{ + yyval.node = NULL; + ; + break;} +case 40: +#line 377 "parse.y" +{ ctxp->package = EXPR_WFL_NODE (yyvsp[-1].node); ; + break;} +case 41: +#line 379 "parse.y" +{yyerror ("Missing name"); RECOVER;; + break;} +case 42: +#line 381 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 45: +#line 391 "parse.y" +{ + tree name = EXPR_WFL_NODE (yyvsp[-1].node), node, last_name; + int i = IDENTIFIER_LENGTH (name)-1; + char *last = &IDENTIFIER_POINTER (name)[i]; + while (last != IDENTIFIER_POINTER (name)) + { + if (last [0] == '.') + break; + last--; + } + last_name = get_identifier (++last); + if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name)) + { + tree err = find_name_in_single_imports (last_name); + if (err && err != name) + parse_error_context + (yyvsp[-1].node, "Ambiguous class: `%s' and `%s'", + IDENTIFIER_POINTER (name), + IDENTIFIER_POINTER (err)); + } + 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; + } + ; + break;} +case 46: +#line 420 "parse.y" +{yyerror ("Missing name"); RECOVER;; + break;} +case 47: +#line 422 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 48: +#line 427 "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)) + { + 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; + ; + break;} +case 49: +#line 439 "parse.y" +{yyerror ("'*' expected"); RECOVER;; + break;} +case 50: +#line 441 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 51: +#line 446 "parse.y" +{ + maybe_generate_clinit (); + yyval.node = yyvsp[0].node; + ; + break;} +case 53: +#line 452 "parse.y" +{ yyval.node = NULL; ; + break;} +case 54: +#line 454 "parse.y" +{ + YYERROR_NOW; + yyerror ("Class or interface declaration expected"); + ; + break;} +case 55: +#line 465 "parse.y" +{ + yyval.value = (1 << yyvsp[0].value); + ; + break;} +case 56: +#line 469 "parse.y" +{ + int acc = (1 << yyvsp[0].value); + if (yyval.value & acc) + parse_error_context + (ctxp->modifier_ctx [yyvsp[0].value], "Modifier `%s' declared twice", + java_accstring_lookup (acc)); + else + { + yyval.value |= acc; + } + ; + break;} +case 57: +#line 485 "parse.y" +{ create_class (yyvsp[-4].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 58: +#line 487 "parse.y" +{ + yyval.node = yyvsp[0].node; + ; + break;} +case 59: +#line 491 "parse.y" +{ create_class (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 60: +#line 493 "parse.y" +{ + yyval.node = yyvsp[0].node; + ; + break;} +case 61: +#line 497 "parse.y" +{yyerror ("Missing class name"); RECOVER;; + break;} +case 62: +#line 499 "parse.y" +{yyerror ("Missing class name"); RECOVER;; + break;} +case 63: +#line 501 "parse.y" +{if (!ctxp->class_err) yyerror ("'{' expected"); DRECOVER(class1);; + break;} +case 64: +#line 503 "parse.y" +{if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;; + break;} +case 65: +#line 507 "parse.y" +{ yyval.node = NULL; ; + break;} +case 66: +#line 509 "parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 67: +#line 511 "parse.y" +{yyerror ("'{' expected"); ctxp->class_err=1;; + break;} +case 68: +#line 513 "parse.y" +{yyerror ("Missing super class name"); ctxp->class_err=1;; + break;} +case 69: +#line 517 "parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 70: +#line 519 "parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 71: +#line 521 "parse.y" +{ + ctxp->class_err=1; + yyerror ("Missing interface name"); + ; + break;} +case 72: +#line 529 "parse.y" +{ + ctxp->interface_number = 1; + yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); + ; + break;} +case 73: +#line 534 "parse.y" +{ + ctxp->interface_number++; + yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE)); + ; + break;} +case 74: +#line 539 "parse.y" +{yyerror ("Missing interface name"); RECOVER;; + break;} +case 75: +#line 544 "parse.y" +{ yyval.node = ctxp->current_parsed_class; ; + break;} +case 76: +#line 546 "parse.y" +{ yyval.node = ctxp->current_parsed_class; ; + break;} +case 82: +#line 559 "parse.y" +{ yyval.node = parse_jdk1_1_error ("instance initializer"); ; + break;} +case 85: +#line 566 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner classe declaration"); ; + break;} +case 86: +#line 568 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner interface declaration"); ; + break;} +case 87: +#line 574 "parse.y" +{ register_fields (0, yyvsp[-2].node, yyvsp[-1].node); ; + break;} +case 88: +#line 576 "parse.y" +{ + check_modifiers + ("Illegal modifier `%s' for field declaration", + yyvsp[-3].value, FIELD_MODIFIERS); + check_modifiers_consistency (yyvsp[-3].value); + register_fields (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node); + ; + break;} +case 90: +#line 589 "parse.y" +{ yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node); ; + break;} +case 91: +#line 591 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 92: +#line 596 "parse.y" +{ yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); ; + break;} +case 93: +#line 598 "parse.y" +{ + if (java_error_count) + yyvsp[0].node = NULL_TREE; + yyval.node = build_tree_list + (yyvsp[-2].node, build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node)); + ; + break;} +case 94: +#line 605 "parse.y" +{ + yyerror ("Missing variable initializer"); + yyval.node = build_tree_list (yyvsp[-2].node, NULL_TREE); + RECOVER; + ; + break;} +case 95: +#line 611 "parse.y" +{ + yyerror ("';' expected"); + yyval.node = build_tree_list (yyvsp[-3].node, NULL_TREE); + RECOVER; + ; + break;} +case 97: +#line 621 "parse.y" +{ yyval.node = build_unresolved_array_type (yyvsp[-2].node); ; + break;} +case 98: +#line 623 "parse.y" +{yyerror ("Invalid declaration"); DRECOVER(vdi);; + break;} +case 99: +#line 625 "parse.y" +{yyerror ("']' expected"); DRECOVER(vdi);; + break;} +case 100: +#line 627 "parse.y" +{yyerror ("Unbalanced ']'"); DRECOVER(vdi);; + break;} +case 102: +#line 633 "parse.y" +{ yyval.node = NULL; ; + break;} +case 103: +#line 639 "parse.y" +{ + current_function_decl = yyvsp[0].node; + source_start_java_method (current_function_decl); + ; + break;} +case 104: +#line 644 "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 657 "parse.y" +{YYNOT_TWICE yyerror ("'{' expected"); RECOVER;; + break;} +case 106: +#line 662 "parse.y" +{ yyval.node = method_header (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 107: +#line 664 "parse.y" +{ yyval.node = method_header (0, void_type_node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 108: +#line 666 "parse.y" +{ yyval.node = method_header (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 109: +#line 668 "parse.y" +{ yyval.node = method_header (yyvsp[-3].value, void_type_node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 110: +#line 670 "parse.y" +{RECOVER;; + break;} +case 111: +#line 672 "parse.y" +{RECOVER;; + break;} +case 112: +#line 674 "parse.y" +{yyerror ("Identifier expected"); RECOVER;; + break;} +case 113: +#line 676 "parse.y" +{yyerror ("Identifier expected"); RECOVER;; + break;} +case 114: +#line 678 "parse.y" +{ + yyerror ("Invalid method declaration, return type required"); + RECOVER; + ; + break;} +case 115: +#line 686 "parse.y" +{ yyval.node = method_declarator (yyvsp[-2].node, NULL_TREE); ; + break;} +case 116: +#line 688 "parse.y" +{ yyval.node = method_declarator (yyvsp[-3].node, yyvsp[-1].node); ; + break;} +case 117: +#line 690 "parse.y" +{ + /* Issue a warning here: obsolete declaration. FIXME */ + yyval.node = NULL; /* FIXME */ + ; + break;} +case 118: +#line 695 "parse.y" +{yyerror ("')' expected"); DRECOVER(method_declarator);; + break;} +case 119: +#line 697 "parse.y" +{yyerror ("']' expected"); RECOVER;; + break;} +case 120: +#line 702 "parse.y" +{ + ctxp->formal_parameter_number = 1; + ; + break;} +case 121: +#line 706 "parse.y" +{ + ctxp->formal_parameter_number += 1; + yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 122: +#line 711 "parse.y" +{yyerror ("Missing formal parameter term"); RECOVER;; + break;} +case 123: +#line 716 "parse.y" +{ + yyval.node = build_tree_list (yyvsp[0].node, yyvsp[-1].node); + ; + break;} +case 124: +#line 720 "parse.y" +{ yyval.node = parse_jdk1_1_error ("final local"); ; + break;} +case 125: +#line 722 "parse.y" +{yyerror ("Missing identifier"); RECOVER;; + break;} +case 126: +#line 724 "parse.y" +{ + SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-2].value)); + yyerror ("Missing identifier"); RECOVER; + ; + break;} +case 127: +#line 731 "parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 128: +#line 733 "parse.y" +{ yyval.node = yyvsp[0].node; ; + break;} +case 129: +#line 735 "parse.y" +{yyerror ("Missing class type term"); RECOVER;; + break;} +case 130: +#line 740 "parse.y" +{ yyval.node = build_tree_list (NULL_TREE, yyvsp[0].node); ; + break;} +case 131: +#line 742 "parse.y" +{ yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyvsp[-2].node); ; + break;} +case 132: +#line 744 "parse.y" +{yyerror ("Missing class type term"); RECOVER;; + break;} +case 135: +#line 751 "parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 136: +#line 757 "parse.y" +{ + RULE ("STATIC_INITIALIZER"); + ; + break;} +case 137: +#line 761 "parse.y" +{ + RULE ("STATIC_INITIALIZER"); + ; + break;} +case 138: +#line 768 "parse.y" +{ + SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value)); + ; + break;} +case 139: +#line 780 "parse.y" +{ + RULE ("CONSTRUCTOR_DECLARATION"); + ; + break;} +case 140: +#line 784 "parse.y" +{ + SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-3].value)); + RULE ("CONSTRUCTOR_DECLARATION (modifier)"); + ; + break;} +case 141: +#line 790 "parse.y" +{ + RULE ("CONSTRUCTOR_DECLARATION"); + ; + break;} +case 142: +#line 795 "parse.y" +{ + SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-4].value)); + RULE ("CONSTRUCTOR_DECLARATION (modifier)"); + ; + break;} +case 151: +#line 822 "parse.y" +{yyval.node = parse_jdk1_1_error ("explicit constructor invocation"); ; + break;} +case 152: +#line 824 "parse.y" +{yyval.node = parse_jdk1_1_error ("explicit constructor invocation"); ; + break;} +case 153: +#line 829 "parse.y" +{ + tree wfl = build_wfl_node (this_identifier_node, + input_filename, 0, 0); + EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location; + yyval.node = wfl; + ; + break;} +case 154: +#line 836 "parse.y" +{ + tree wfl = build_wfl_node (super_identifier_node, + input_filename, 0, 0); + EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location; + yyval.node = wfl; + ; + break;} +case 155: +#line 848 "parse.y" +{ create_interface (0, yyvsp[0].node, NULL_TREE); ; + break;} +case 156: +#line 850 "parse.y" +{ + yyval.node = yyvsp[0].node; + ; + break;} +case 157: +#line 854 "parse.y" +{ create_interface (yyvsp[-2].value, yyvsp[0].node, NULL_TREE); ; + break;} +case 158: +#line 856 "parse.y" +{ + yyval.node = yyvsp[0].node; + ; + break;} +case 159: +#line 860 "parse.y" +{ create_interface (0, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 160: +#line 862 "parse.y" +{ + yyval.node = yyvsp[0].node; + ; + break;} +case 161: +#line 866 "parse.y" +{ create_interface (yyvsp[-3].value, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 162: +#line 868 "parse.y" +{ + yyval.node = yyvsp[0].node; + ; + break;} +case 163: +#line 872 "parse.y" +{yyerror ("(here)'{' expected"); RECOVER;; + break;} +case 164: +#line 874 "parse.y" +{yyerror ("(there)'{' expected"); RECOVER;; + break;} +case 165: +#line 879 "parse.y" +{ + ctxp->interface_number = 1; + yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); + ; + break;} +case 166: +#line 884 "parse.y" +{ + ctxp->interface_number++; + yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE)); + ; + break;} +case 167: +#line 889 "parse.y" +{yyerror ("Invalid interface type"); RECOVER;; + break;} +case 168: +#line 891 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 169: +#line 896 "parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 170: +#line 898 "parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 175: +#line 910 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class declaration"); ; + break;} +case 176: +#line 912 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner interface declaration"); ; + break;} +case 178: +#line 921 "parse.y" +{ + check_abstract_method_header (yyvsp[-1].node); + current_function_decl = NULL_TREE; /* FIXME ? */ + ; + break;} +case 179: +#line 926 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 180: +#line 932 "parse.y" +{ + RULE ("ARRAY_INITIALIZER (empty)"); + ; + break;} +case 181: +#line 936 "parse.y" +{ + RULE ("ARRAY_INITIALIZER (variable)"); + ; + break;} +case 182: +#line 940 "parse.y" +{ + RULE ("ARRAY_INITIALIZER (,)"); + ; + break;} +case 183: +#line 944 "parse.y" +{ + RULE ("ARRAY_INITIALIZER (variable, ,)"); + ; + break;} +case 186: +#line 953 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 187: +#line 959 "parse.y" +{ yyval.node = size_zero_node; ; + break;} +case 188: +#line 961 "parse.y" +{ enter_block (); ; + break;} +case 189: +#line 964 "parse.y" +{ + maybe_absorb_scoping_blocks (); + yyval.node = exit_block (); + ; + break;} +case 193: +#line 978 "parse.y" +{ yyval.node = java_method_add_stmt (current_function_decl, yyvsp[0].node); ; + break;} +case 194: +#line 980 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class declaration"); ; + break;} +case 196: +#line 989 "parse.y" +{ declare_local_variables (0, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 197: +#line 991 "parse.y" +{ declare_local_variables (yyvsp[-2].value, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 203: +#line 1001 "parse.y" +{ + /* If the for loop is unlabeled, we must return the + block it was defined it. It our last chance to + get a hold on it. */ + if (!LOOP_HAS_LABEL_P (yyval.node)) + yyval.node = exit_block (); + ; + break;} +case 220: +#line 1034 "parse.y" +{ yyval.node = size_zero_node; ; + break;} +case 221: +#line 1039 "parse.y" +{ + yyval.node = build_labeled_block (EXPR_WFL_LINECOL (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 1050 "parse.y" +{ + yyval.node = complete_labeled_statement (yyvsp[-1].node, yyvsp[0].node); + pop_labeled_block (); + POP_LABELED_BLOCK (); + ; + break;} +case 223: +#line 1056 "parse.y" +{yyerror ("':' expected"); RECOVER;; + break;} +case 224: +#line 1061 "parse.y" +{ + yyval.node = complete_labeled_statement (yyvsp[-1].node, yyvsp[0].node); + pop_labeled_block (); + POP_LABELED_BLOCK (); + ; + break;} +case 225: +#line 1072 "parse.y" +{ + /* We have a statement. Generate a WFL around it so + we can debug it */ + yyval.node = build_expr_wfl (yyvsp[-1].node, input_filename, lineno, 0); + /* We know we have a statement, so set the debug + info to be eventually generate here. */ + yyval.node = JAVA_MAYBE_GENERATE_DEBUG_INFO (yyval.node); + ; + break;} +case 226: +#line 1081 "parse.y" +{ + if (ctxp->prevent_ese != lineno) + yyerror ("Invalid expression statement"); + DRECOVER (expr_stmt); + ; + break;} +case 227: +#line 1087 "parse.y" +{ + if (ctxp->prevent_ese != lineno) + yyerror ("Invalid expression statement"); + DRECOVER (expr_stmt); + ; + break;} +case 228: +#line 1093 "parse.y" +{ + if (ctxp->prevent_ese != lineno) + yyerror ("Invalid expression statement"); + DRECOVER (expr_stmt); + ; + break;} +case 229: +#line 1099 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 230: +#line 1101 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 231: +#line 1103 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 232: +#line 1105 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 233: +#line 1107 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 234: +#line 1109 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 235: +#line 1111 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 236: +#line 1113 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 237: +#line 1115 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 245: +#line 1130 "parse.y" +{ yyval.node = build_if_else_statement (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node, NULL_TREE); ; + break;} +case 246: +#line 1132 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 247: +#line 1134 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 248: +#line 1136 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 249: +#line 1141 "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 1146 "parse.y" +{ yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ; + break;} +case 251: +#line 1151 "parse.y" +{ + TREE_OPERAND (yyvsp[-1].node, 1) = yyvsp[0].node; + yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-1].node), yyvsp[-1].node); + ; + break;} +case 252: +#line 1159 "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 253: +#line 1164 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 254: +#line 1166 "parse.y" +{yyerror ("Missing term or ')'"); DRECOVER(switch_statement);; + break;} +case 255: +#line 1168 "parse.y" +{yyerror ("'{' expected"); RECOVER;; + break;} +case 256: +#line 1173 "parse.y" +{ yyval.node = NULL_TREE; ; + break;} +case 257: +#line 1175 "parse.y" +{ yyval.node = build_tree_list (yyvsp[-1].node, NULL_TREE); ; + break;} +case 258: +#line 1177 "parse.y" +{ yyval.node = yyvsp[-1].node; ; + break;} +case 259: +#line 1179 "parse.y" +{ + /* Switch labels alone are empty switch statements */ + tree sl = build_tree_list (yyvsp[-1].node, NULL_TREE); + TREE_CHAIN (sl) = yyvsp[-2].node; + yyval.node = sl; + ; + break;} +case 261: +#line 1190 "parse.y" +{ + TREE_CHAIN (yyvsp[0].node) = yyvsp[-1].node; + yyval.node = yyvsp[0].node; + ; + break;} +case 262: +#line 1198 "parse.y" +{ yyval.node = build_tree_list (yyvsp[-1].node, exit_block ()); ; + break;} +case 263: +#line 1203 "parse.y" +{ + /* All statements attached to this group of cases + will be stored in a block */ + enter_block (); + yyval.node = yyvsp[0].node; + ; + break;} +case 265: +#line 1213 "parse.y" +{ + TREE_CHAIN (yyvsp[0].node) = yyvsp[-1].node; + yyval.node = yyvsp[0].node; + ; + break;} +case 266: +#line 1221 "parse.y" +{ + yyval.node = build1 (CASE_EXPR, NULL_TREE, yyvsp[-1].node); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-2].operator.location; + ; + break;} +case 267: +#line 1226 "parse.y" +{ + yyval.node = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-1].operator.location; + ; + break;} +case 268: +#line 1231 "parse.y" +{yyerror ("Missing or invalid constant expression"); RECOVER;; + break;} +case 269: +#line 1233 "parse.y" +{yyerror ("':' expected"); RECOVER;; + break;} +case 270: +#line 1235 "parse.y" +{yyerror ("':' expected"); RECOVER;; + break;} +case 271: +#line 1240 "parse.y" +{ + tree body = build_loop_body (yyvsp[-2].operator.location, yyvsp[-1].node, 0); + yyval.node = build_new_loop (body); + ; + break;} +case 272: +#line 1248 "parse.y" +{ yyval.node = complete_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ; + break;} +case 273: +#line 1250 "parse.y" +{YYERROR_NOW; yyerror ("'(' expected"); RECOVER;; + break;} +case 274: +#line 1252 "parse.y" +{yyerror ("Missing term and ')' expected"); RECOVER;; + break;} +case 275: +#line 1254 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 276: +#line 1259 "parse.y" +{ yyval.node = complete_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ; + break;} +case 277: +#line 1264 "parse.y" +{ + tree body = build_loop_body (0, NULL_TREE, 1); + yyval.node = build_new_loop (body); + ; + break;} +case 278: +#line 1273 "parse.y" +{ yyval.node = complete_loop_body (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[-5].node, 1); ; + break;} +case 279: +#line 1278 "parse.y" +{ yyval.node = complete_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);; + break;} +case 280: +#line 1280 "parse.y" +{ + yyval.node = complete_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; + ; + break;} +case 281: +#line 1287 "parse.y" +{yyerror ("Invalid control expression"); RECOVER;; + break;} +case 282: +#line 1289 "parse.y" +{yyerror ("Invalid update expression"); RECOVER;; + break;} +case 283: +#line 1291 "parse.y" +{yyerror ("Invalid update expression"); RECOVER;; + break;} +case 284: +#line 1296 "parse.y" +{ yyval.node = complete_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);; + break;} +case 285: +#line 1298 "parse.y" +{ + yyval.node = complete_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; + ; + break;} +case 286: +#line 1308 "parse.y" +{ + /* This scope defined for local variable that may be + defined within the scope of the for loop */ + enter_block (); + ; + break;} +case 287: +#line 1314 "parse.y" +{yyerror ("'(' expected"); DRECOVER(for_1);; + break;} +case 288: +#line 1316 "parse.y" +{yyerror ("Invalid init statement"); RECOVER;; + break;} +case 289: +#line 1321 "parse.y" +{ + /* We now declare the loop body. The loop is + declared as a for loop. */ + tree body = build_loop_body (0, NULL_TREE, 0); + yyval.node = build_new_loop (body); + IS_FOR_LOOP_P (yyval.node) = 1; + /* The loop is added to the current block the for + statement is defined within */ + java_method_add_stmt (current_function_decl, yyval.node); + ; + break;} +case 290: +#line 1333 "parse.y" +{ yyval.node = size_zero_node; ; + break;} +case 291: +#line 1335 "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 292: +#line 1341 "parse.y" +{ + /* Local variable are recorded within the previously + defined block scope */ + yyval.node = NULL_TREE; + ; + break;} +case 293: +#line 1347 "parse.y" +{yyerror ("';' expected"); DRECOVER(for_init_1);; + break;} +case 294: +#line 1351 "parse.y" +{yyval.node = size_zero_node;; + break;} +case 295: +#line 1353 "parse.y" +{ yyval.node = build_debugable_stmt (BUILD_LOCATION (), yyvsp[0].node); ; + break;} +case 296: +#line 1358 "parse.y" +{ yyval.node = add_stmt_to_compound (NULL_TREE, NULL_TREE, yyvsp[0].node); ; + break;} +case 297: +#line 1360 "parse.y" +{ yyval.node = add_stmt_to_compound (yyvsp[-2].node, NULL_TREE, yyvsp[0].node); ; + break;} +case 298: +#line 1362 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 299: +#line 1367 "parse.y" +{ yyval.node = build_bc_statement (yyvsp[-1].operator.location, 1, NULL_TREE); ; + break;} +case 300: +#line 1369 "parse.y" +{ yyval.node = build_bc_statement (yyvsp[-2].operator.location, 1, yyvsp[-1].node); ; + break;} +case 301: +#line 1371 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 302: +#line 1373 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 303: +#line 1378 "parse.y" +{ yyval.node = build_bc_statement (yyvsp[-1].operator.location, 0, NULL_TREE); ; + break;} +case 304: +#line 1380 "parse.y" +{ yyval.node = build_bc_statement (yyvsp[-2].operator.location, 0, yyvsp[-1].node); ; + break;} +case 305: +#line 1382 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 306: +#line 1384 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 307: +#line 1389 "parse.y" +{ yyval.node = build_return (yyvsp[-1].operator.location, NULL_TREE); ; + break;} +case 308: +#line 1391 "parse.y" +{ yyval.node = build_return (yyvsp[-2].operator.location, yyvsp[-1].node); ; + break;} +case 309: +#line 1393 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 310: +#line 1395 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 311: +#line 1400 "parse.y" +{ + yyval.node = build1 (THROW_EXPR, NULL_TREE, yyvsp[-1].node); + EXPR_WFL_LINECOL (yyval.node) = yyvsp[-2].operator.location; + ; + break;} +case 312: +#line 1405 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 313: +#line 1407 "parse.y" +{yyerror ("';' expected"); RECOVER;; + break;} +case 314: +#line 1412 "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 315: +#line 1418 "parse.y" +{yyerror ("'{' expected"); RECOVER;; + break;} +case 316: +#line 1420 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 317: +#line 1422 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 318: +#line 1424 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 319: +#line 1429 "parse.y" +{ + if ((1 << yyvsp[0].value) != ACC_SYNCHRONIZED) + fatal ("synchronized was '%d' - yyparse", (1 << yyvsp[0].value)); + ; + break;} +case 320: +#line 1437 "parse.y" +{ yyval.node = build_try_statement (yyvsp[-2].operator.location, yyvsp[-1].node, yyvsp[0].node, NULL_TREE); ; + break;} +case 321: +#line 1439 "parse.y" +{ yyval.node = build_try_statement (yyvsp[-2].operator.location, yyvsp[-1].node, NULL_TREE, yyvsp[0].node); ; + break;} +case 322: +#line 1441 "parse.y" +{ yyval.node = build_try_statement (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ; + break;} +case 323: +#line 1443 "parse.y" +{yyerror ("'{' expected"); DRECOVER (try_statement);; + break;} +case 325: +#line 1449 "parse.y" +{ + TREE_CHAIN (yyvsp[0].node) = yyvsp[-1].node; + yyval.node = yyvsp[0].node; + ; + break;} +case 326: +#line 1457 "parse.y" +{ + java_method_add_stmt (current_function_decl, yyvsp[0].node); + exit_block (); + yyval.node = yyvsp[-1].node; + ; + break;} +case 327: +#line 1465 "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 328: +#line 1481 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 329: +#line 1483 "parse.y" +{yyerror ("Missing term or ')' expected"); DRECOVER (2);; + break;} +case 330: +#line 1485 "parse.y" +{yyerror ("')' expected"); DRECOVER (1);; + break;} +case 331: +#line 1490 "parse.y" +{ + yyval.node = build (FINALLY_EXPR, NULL_TREE, + create_label_decl (generate_name ()), yyvsp[0].node); + ; + break;} +case 332: +#line 1495 "parse.y" +{yyerror ("'{' expected"); RECOVER; ; + break;} +case 336: +#line 1507 "parse.y" +{ yyval.node = build_this (yyvsp[0].operator.location); ; + break;} +case 337: +#line 1509 "parse.y" +{yyval.node = yyvsp[-1].node;; + break;} +case 342: +#line 1518 "parse.y" +{ yyval.node = parse_jdk1_1_error ("class literals"); ; + break;} +case 343: +#line 1520 "parse.y" +{ yyval.node = parse_jdk1_1_error ("class literals"); ; + break;} +case 344: +#line 1522 "parse.y" +{ yyval.node = parse_jdk1_1_error ("class literals"); ; + break;} +case 345: +#line 1527 "parse.y" +{ yyval.node = parse_jdk1_1_error ("class literals"); ; + break;} +case 346: +#line 1529 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 347: +#line 1531 "parse.y" +{yyerror ("'class' or 'this' expected" ); RECOVER;; + break;} +case 348: +#line 1533 "parse.y" +{yyerror ("'class' expected" ); RECOVER;; + break;} +case 349: +#line 1535 "parse.y" +{yyerror ("'class' expected" ); RECOVER;; + break;} +case 350: +#line 1540 "parse.y" +{ yyval.node = build_new_invocation (yyvsp[-3].node, yyvsp[-1].node); ; + break;} +case 351: +#line 1542 "parse.y" +{ yyval.node = build_new_invocation (yyvsp[-2].node, NULL_TREE); ; + break;} +case 352: +#line 1547 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class instance creation"); ; + break;} +case 353: +#line 1549 "parse.y" +{ yyval.node = parse_jdk1_1_error ("inner class instance creation"); ; + break;} +case 358: +#line 1558 "parse.y" +{yyerror ("'(' expected"); DRECOVER(new_1);; + break;} +case 359: +#line 1560 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 360: +#line 1562 "parse.y" +{yyerror ("')' or term expected"); RECOVER;; + break;} +case 361: +#line 1564 "parse.y" +{yyerror ("')' expected"); RECOVER;; + break;} +case 362: +#line 1566 "parse.y" +{YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;; + break;} +case 363: +#line 1568 "parse.y" +{yyerror ("'(' expected"); RECOVER;; + break;} +case 366: +#line 1578 "parse.y" +{ + yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, NULL_TREE); + ctxp->formal_parameter_number = 1; + ; + break;} +case 367: +#line 1583 "parse.y" +{ + ctxp->formal_parameter_number += 1; + yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyvsp[-2].node); + ; + break;} +case 368: +#line 1588 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 369: +#line 1593 "parse.y" +{ yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); ; + break;} +case 370: +#line 1595 "parse.y" +{ yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); ; + break;} +case 371: +#line 1597 "parse.y" +{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, ctxp->osb_number); ; + break;} +case 372: +#line 1599 "parse.y" +{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, ctxp->osb_number); ; + break;} +case 373: +#line 1603 "parse.y" +{ yyval.node = parse_jdk1_1_error ("anonymous array"); ; + break;} +case 374: +#line 1605 "parse.y" +{ yyval.node = parse_jdk1_1_error ("anonymous array"); ; + break;} +case 375: +#line 1607 "parse.y" +{yyerror ("'[' expected"); DRECOVER ("]");; + break;} +case 376: +#line 1609 "parse.y" +{yyerror ("']' expected"); RECOVER;; + break;} +case 377: +#line 1614 "parse.y" +{ yyval.node = build_tree_list (NULL_TREE, yyvsp[0].node); ; + break;} +case 378: +#line 1616 "parse.y" +{ yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyval.node); ; + break;} +case 379: +#line 1621 "parse.y" +{ + EXPR_WFL_LINECOL (yyvsp[-1].node) = yyvsp[-2].operator.location; + yyval.node = yyvsp[-1].node; + ; + break;} +case 380: +#line 1626 "parse.y" +{yyerror ("']' expected"); RECOVER;; + break;} +case 381: +#line 1628 "parse.y" +{ + yyerror ("Missing term"); + yyerror ("']' expected"); + RECOVER; + ; + break;} +case 382: +#line 1637 "parse.y" +{ ctxp->osb_number = 1; ; + break;} +case 383: +#line 1639 "parse.y" +{ ctxp->osb_number++; ; + break;} +case 384: +#line 1641 "parse.y" +{ yyerror ("']' expected"); RECOVER;; + break;} +case 385: +#line 1646 "parse.y" +{ yyval.node = make_qualified_primary (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); ; + break;} +case 386: +#line 1648 "parse.y" +{ + tree super_wfl = + build_wfl_node (super_identifier_node, + input_filename, 0, 0); + 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 387: +#line 1656 "parse.y" +{yyerror ("Field expected"); DRECOVER (super_field_acces);; + break;} +case 388: +#line 1661 "parse.y" +{ yyval.node = build_method_invocation (yyvsp[-2].node, NULL_TREE); ; + break;} +case 389: +#line 1663 "parse.y" +{ yyval.node = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); ; + break;} +case 390: +#line 1665 "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); + ; + break;} +case 391: +#line 1670 "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); + ; + break;} +case 392: +#line 1675 "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); + ; + break;} +case 393: +#line 1684 "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); + ; + break;} +case 394: +#line 1697 "parse.y" +{ yyerror ("'(' expected"); DRECOVER (method_invocation); ; + break;} +case 395: +#line 1699 "parse.y" +{ yyerror ("'(' expected"); DRECOVER (method_invocation); ; + break;} +case 396: +#line 1704 "parse.y" +{ yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); ; + break;} +case 397: +#line 1706 "parse.y" +{ yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); ; + break;} +case 398: +#line 1708 "parse.y" +{ + yyerror ("Missing term and ']' expected"); + DRECOVER(array_access); + ; + break;} +case 399: +#line 1713 "parse.y" +{ + yyerror ("']' expected"); + DRECOVER(array_access); + ; + break;} +case 400: +#line 1718 "parse.y" +{ + yyerror ("Missing term and ']' expected"); + DRECOVER(array_access); + ; + break;} +case 401: +#line 1723 "parse.y" +{ + yyerror ("']' expected"); + DRECOVER(array_access); + ; + break;} +case 406: +#line 1738 "parse.y" +{ yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); ; + break;} +case 407: +#line 1743 "parse.y" +{ yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); ; + break;} +case 410: +#line 1750 "parse.y" +{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; + break;} +case 411: +#line 1752 "parse.y" +{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; + break;} +case 413: +#line 1755 "parse.y" +{yyerror ("Missing term"); RECOVER; + break;} +case 414: +#line 1757 "parse.y" +{yyerror ("Missing term"); RECOVER; + break;} +case 415: +#line 1762 "parse.y" +{yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); ; + break;} +case 416: +#line 1764 "parse.y" +{yyerror ("Missing term"); RECOVER; + break;} +case 417: +#line 1769 "parse.y" +{yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); ; + break;} +case 418: +#line 1771 "parse.y" +{yyerror ("Missing term"); RECOVER; + break;} +case 420: +#line 1777 "parse.y" +{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; + break;} +case 421: +#line 1779 "parse.y" +{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ; + break;} +case 423: +#line 1782 "parse.y" +{yyerror ("Missing term"); RECOVER; + break;} +case 424: +#line 1784 "parse.y" +{yyerror ("Missing term"); RECOVER; + break;} +case 425: +#line 1789 "parse.y" +{ + tree type = yyvsp[-3].node; + while (ctxp->osb_number--) + type = build_java_array_type (type, -1); + yyval.node = build_cast (yyvsp[-4].operator.location, type, yyvsp[0].node); + ; + break;} +case 426: +#line 1796 "parse.y" +{ yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); ; + break;} +case 427: +#line 1798 "parse.y" +{ yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); ; + break;} +case 428: +#line 1800 "parse.y" +{ + char *ptr; + while (ctxp->osb_number--) + obstack_1grow (&temporary_obstack, '['); + obstack_grow0 (&temporary_obstack, + IDENTIFIER_POINTER (EXPR_WFL_NODE (yyvsp[-3].node)), + IDENTIFIER_LENGTH (EXPR_WFL_NODE (yyvsp[-3].node))); + ptr = obstack_finish (&temporary_obstack); + EXPR_WFL_NODE (yyvsp[-3].node) = get_identifier (ptr); + yyval.node = build_cast (yyvsp[-4].operator.location, yyvsp[-3].node, yyvsp[0].node); + ; + break;} +case 429: +#line 1812 "parse.y" +{yyerror ("']' expected, invalid type expression");; + break;} +case 430: +#line 1814 "parse.y" +{ + if (ctxp->prevent_ese != lineno) + yyerror ("Invalid type expression"); RECOVER; + RECOVER; + ; + break;} +case 431: +#line 1820 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 432: +#line 1822 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 433: +#line 1824 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 435: +#line 1830 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), + yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 436: +#line 1835 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 437: +#line 1840 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 438: +#line 1845 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 439: +#line 1847 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 440: +#line 1849 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 442: +#line 1855 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 443: +#line 1860 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 444: +#line 1865 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 445: +#line 1867 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 447: +#line 1873 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 448: +#line 1878 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 449: +#line 1883 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 450: +#line 1888 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 451: +#line 1890 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 452: +#line 1892 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 454: +#line 1898 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 455: +#line 1903 "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 1908 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 457: +#line 1913 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 459: +#line 1919 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 460: +#line 1921 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 461: +#line 1923 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 462: +#line 1925 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 463: +#line 1927 "parse.y" +{yyerror ("Invalid reference type"); RECOVER;; + break;} +case 465: +#line 1933 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 466: +#line 1938 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 467: +#line 1943 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 468: +#line 1945 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 470: +#line 1951 "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 1956 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 473: +#line 1962 "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 1967 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 476: +#line 1973 "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 1978 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 479: +#line 1984 "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 1989 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 482: +#line 1995 "parse.y" +{ + yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location, + yyvsp[-2].node, yyvsp[0].node); + ; + break;} +case 483: +#line 2000 "parse.y" +{yyerror ("Missing term"); RECOVER;; + break;} +case 486: +#line 2007 "parse.y" +{ + YYERROR_NOW; + yyerror ("Missing term"); + DRECOVER (1); + ; + break;} +case 487: +#line 2013 "parse.y" +{yyerror ("Missing term"); DRECOVER (2);; + break;} +case 488: +#line 2015 "parse.y" +{yyerror ("Missing term"); DRECOVER (3);; + break;} +case 491: +#line 2025 "parse.y" +{ yyval.node = build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ; + break;} +case 492: +#line 2027 "parse.y" +{ + if (ctxp->prevent_ese != lineno) + yyerror ("Missing term"); + DRECOVER (assign); + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 498 "bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; +} +#line 2053 "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 + richer context. */ +static int force_error = 0; + +/* Create a new parser context and make it the current one. */ + +void +java_push_parser_context () +{ + struct parser_ctxt *new = + (struct parser_ctxt *)malloc(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; +} + +void +java_parser_context_save_global () +{ + ctxp->finput = finput; + ctxp->lineno = lineno; + ctxp->current_class = current_class; + ctxp->filename = input_filename; + ctxp->current_function_decl = current_function_decl; +} + +void +java_parser_context_restore_global () +{ + finput = ctxp->finput; + lineno = ctxp->lineno; + current_class = ctxp->current_class; + input_filename = ctxp->filename; + current_function_decl = ctxp->current_function_decl; +} + +void +java_pop_parser_context () +{ + tree current; + struct parser_ctxt *toFree = ctxp; + struct parser_ctxt *next = ctxp->next; + + if (next) + { + next->incomplete_class = ctxp->incomplete_class; + lineno = ctxp->lineno; + finput = ctxp->finput; + current_class = ctxp->current_class; + } + + /* Set the single import class file flag to 0 for the current list + of imported things */ + for (current = ctxp->import_list; current; current = TREE_CHAIN (current)) + IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0; + + /* And restore those of the previous context */ + 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); +} + +/* 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 size_zero_node; +} + +static int do_warning = 0; + +void +yyerror (msg) + char *msg; +{ + static java_lc elc; + static int prev_lineno; + static char *prev_msg; + + int save_lineno; + char *remainder, *code_from_source; + extern struct obstack temporary_obstack; + + if (!force_error && prev_lineno == lineno) + return; + + /* Save current error location but report latter, when the context is + richer. */ + if (ctxp->java_error_flag == 0) + { + ctxp->java_error_flag = 1; + elc = ctxp->elc; + /* Do something to use the previous line if we're reaching the + end of the file... */ +#ifdef VERBOSE_SKELETON + printf ("* Error detected (%s)\n", (msg ? msg : "(null)")); +#endif + return; + } + + /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */ + if (!force_error && msg == prev_msg && prev_lineno == elc.line) + return; + + ctxp->java_error_flag = 0; + if (do_warning) + java_warning_count++; + else + java_error_count++; + + if (elc.col == 0 && msg[1] == ';') + { + elc.col = ctxp->p_line->char_col-1; + elc.line = ctxp->p_line->lineno; + } + + save_lineno = lineno; + prev_lineno = lineno = elc.line; + prev_msg = msg; + + code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col); + obstack_grow0 (&temporary_obstack, + code_from_source, strlen (code_from_source)); + remainder = obstack_finish (&temporary_obstack); + if (do_warning) + warning ("%s.\n%s", msg, remainder); + else + error ("%s.\n%s", msg, remainder); + + /* This allow us to cheaply avoid an extra 'Invalid expression + statement' error report when errors have been already reported on + the same line. This occurs when we report an error but don't have + a synchronization point other than ';', which + expression_statement is the only one to take care of. */ + ctxp->prevent_ese = lineno = save_lineno; +} + +static void +parse_error (msg) + char *msg; +{ + java_error (NULL); + java_error (msg); +} + +/* Issue an error message at a current source line CL */ + +static void +parse_error_context VPROTO ((tree cl, char *msg, ...)) +{ +#ifndef __STDC__ + tree cl; + char *msg; +#endif + char buffer [4096]; + va_list ap; + + VA_START (ap, msg); +#ifndef __STDC__ + cl = va_arg (ap, tree); + msg = va_arg (ap, 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 a warning at a current source line CL */ + +static void +parse_warning_context VPROTO ((tree cl, char *msg, ...)) +{ +#ifndef __STDC__ + tree cl; + char *msg; +#endif + char buffer [4096]; + va_list ap; + + VA_START (ap, msg); +#ifndef __STDC__ + cl = va_arg (ap, tree); + msg = va_arg (ap, 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); + do_warning = force_error = 0; +} + +void +java_report_errors () +{ + if (java_error_count) + fprintf (stderr, "%d error%s", + java_error_count, (java_error_count == 1 ? "" : "s")); + if (java_warning_count) + fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""), + java_warning_count, (java_warning_count == 1 ? "" : "s")); + if (java_error_count || java_warning_count) + putc ('\n', stderr); +} + +static char * +java_accstring_lookup (flags) + int flags; +{ + static char buffer [80]; +#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;} + + /* Access modifier looked-up first for easier report on forbidden + access. */ + if (flags & ACC_PUBLIC) COPY_RETURN ("public"); + if (flags & ACC_PRIVATE) COPY_RETURN ("private"); + if (flags & ACC_PROTECTED) COPY_RETURN ("protected"); + if (flags & ACC_STATIC) COPY_RETURN ("static"); + if (flags & ACC_FINAL) COPY_RETURN ("final"); + if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized"); + if (flags & ACC_VOLATILE) COPY_RETURN ("volatile"); + if (flags & ACC_TRANSIENT) COPY_RETURN ("transient"); + if (flags & ACC_NATIVE) COPY_RETURN ("native"); + if (flags & ACC_INTERFACE) COPY_RETURN ("interface"); + if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract"); + + buffer [0] = '\0'; + return buffer; +#undef COPY_RETURN +} + +/* Issuing error messages upon redefinition of classes, interfaces or + variables. */ + +static void +classitf_redefinition_error (context, id, decl, cl) + char *context; + tree id, decl, cl; +{ + parse_error_context (cl, "%s `%s' already defined in %s:%d", + context, IDENTIFIER_POINTER (id), + DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl)); + /* 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) == TREE_LIST) + type_name = IDENTIFIER_POINTER (TYPE_NAME (TREE_PURPOSE (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 (&more_dims [string]); + + /* If type already is a reference on an array, get the base type */ + if ((TREE_CODE (type) == POINTER_TYPE) && + TYPE_ARRAY_P (TREE_TYPE (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); + 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. */ + +static tree +build_unresolved_array_type (type_or_wfl) + tree type_or_wfl; +{ + char *ptr; + + /* TYPE_OR_WFL might be an array on a primitive type. In this case, + just create a array type */ + if (TREE_CODE (type_or_wfl) == RECORD_TYPE) + { + tree type = build_java_array_type (type_or_wfl, -1); + CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl); + return type; + } + + obstack_1grow (&temporary_obstack, '['); + obstack_grow0 (&temporary_obstack, + IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)), + IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl))); + ptr = obstack_finish (&temporary_obstack); + return build_expr_wfl (get_identifier (ptr), + EXPR_WFL_FILENAME (type_or_wfl), + EXPR_WFL_LINENO (type_or_wfl), + EXPR_WFL_COLNO (type_or_wfl)); +} + +/* Check modifiers. If one doesn't fit, retrieve it in its declaration line + and point it out. */ + +static void +check_modifiers (message, value, mask) + char *message; + int value; + int mask; +{ + /* Should point out the one that don't fit. ASCII/unicode, + going backward. FIXME */ + if (value & ~mask) + { + int i, remainder = value & ~mask; + for (i = 0; i <= 10; i++) + if ((1 << i) & remainder) + parse_error_context (ctxp->modifier_ctx [i], message, + java_accstring_lookup (1 << i)); + } +} + +static void +parser_add_interface (class_decl, interface_decl, wfl) + tree class_decl, interface_decl, wfl; +{ + if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl))) + parse_error_context (wfl, "Interface `%s' repeated", + IDENTIFIER_POINTER (DECL_NAME (interface_decl))); +} + +/* Bulk of common class/interface checks. Return 1 if an error was + encountered. TAG is 0 for a class, 1 for an interface. */ + +static int +check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl) + int is_interface, flags; + tree raw_name, qualified_name, decl, cl; +{ + tree node; + + if (!quiet_flag) + fprintf (stderr, " %s %s", (is_interface ? "interface" : "class"), + IDENTIFIER_POINTER (qualified_name)); + + /* Scope of an interface/class type name: + - Can't be imported by a single type import + - Can't already exists in the package */ + if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name) + && (node = find_name_in_single_imports (raw_name))) + { + parse_error_context + (cl, "%s name `%s' clashes with imported type `%s'", + (is_interface ? "Interface" : "Class"), + IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node)); + return 1; + } + if (decl && CLASS_COMPLETE_P (decl)) + { + classitf_redefinition_error ((is_interface ? "Interface" : "Class"), + qualified_name, decl, cl); + return 1; + } + + /* If public, file name should match class/interface name */ + if (flags & ACC_PUBLIC) + { + char *f; + + /* 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++; + if (strncmp (IDENTIFIER_POINTER (raw_name), + f , IDENTIFIER_LENGTH (raw_name)) || + f [IDENTIFIER_LENGTH (raw_name)] != '.') + parse_error_context (cl, "Public %s `%s' must be defined in a file " + "called `%s.java'", + (is_interface ? "interface" : "class"), + IDENTIFIER_POINTER (qualified_name), + IDENTIFIER_POINTER (raw_name)); + } + + check_modifiers ((is_interface ? + "Illegal modifier `%s' for interface declaration" : + "Illegal modifier `%s' for class declaration"), flags, + (is_interface ? INTERFACE_MODIFIERS : CLASS_MODIFIERS)); + return 0; +} + +/* If DECL is NULL, create and push a new DECL, record the current + line CL and do other maintenance things. */ + +static tree +maybe_create_class_interface_decl (decl, qualified_name, cl) + tree decl, qualified_name, cl; +{ + if (decl) + DECL_ARTIFICIAL (decl) = 1; /* FIXME */ + else + 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); + CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1; + + ctxp->current_parsed_class = decl; + + /* Link the declaration to the already seen ones */ + TREE_CHAIN (decl) = ctxp->class_list; + ctxp->class_list = decl; + /* Install a new dependency list element */ + create_jdep_list (ctxp); + + SOURCE_FRONTEND_DEBUG (("Defining class/interface %s", + IDENTIFIER_POINTER (qualified_name))); + return decl; +} + +static void +add_superinterfaces (decl, interface_list) + tree decl, interface_list; +{ + tree node; + /* Superinterface(s): if present and defined, parser_check_super_interface () + takes care of ensuring that: + - This is an accessible interface type, + - Circularity detection. + parser_add_interface is then called. If present but not defined, + the check operation is delayed until the super interface gets + 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)))) + { + if (!parser_check_super_interface (interface_decl, decl, current)) + parser_add_interface (decl, interface_decl, current); + } + else + register_incomplete_type (JDEP_INTERFACE, + current, decl, NULL_TREE); + } +} + +/* Create an interface in pass1 and return its decl. Return the + interface's decl in pass 2. */ + +static tree +create_interface (flags, id, super) + int flags; + tree id, super; +{ + tree raw_name = EXPR_WFL_NODE (id); + tree q_name = parser_qualified_classname (id); + tree decl = IDENTIFIER_CLASS_VALUE (q_name); + + EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */ + + /* Basic checks: scope, redefinition, modifiers */ + if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id)) + return NULL_TREE; + + /* Interface modifiers check + - 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) + parse_warning_context + (MODIFIER_WFL (ABSTRACT_TK), + "Obsolete 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), + object_type_node, ctxp->interface_number); + ctxp->interface_number = 0; + CLASS_COMPLETE_P (decl) = 1; + add_superinterfaces (decl, super); + + return decl; +} + +/* Create an class in pass1 and return its decl. Return class + interface's decl in pass 2. */ + +static tree +create_class (flags, id, super, interfaces) + int flags; + tree id, super, interfaces; +{ + tree raw_name = EXPR_WFL_NODE (id); + tree class_id, decl; + tree super_decl = NULL, super_decl_type; + + class_id = parser_qualified_classname (id); + decl = IDENTIFIER_CLASS_VALUE (class_id); + EXPR_WFL_NODE (id) = class_id; + + /* Basic check: scope, redefinition, modifiers */ + if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id)) + return NULL_TREE; + + /* Class modifier check: + - Allowed modifier (already done at that point) + - abstract AND final forbidden + - Public classes defined in the correct file */ + if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL)) + parse_error_context (id, "Class `%s' can't be declared both abstract " + "and final", IDENTIFIER_POINTER (raw_name)); + + /* Create a new decl if DECL is NULL, otherwise fix it */ + decl = maybe_create_class_interface_decl (decl, class_id, id); + + /* If SUPER exists, use it, otherwise use Object */ + if (super) + { + /* Can't extend java.lang.Object */ + if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node) + { + parse_error_context (id, "Can't extend `java.lang.Object'"); + 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); + } + else if (TREE_TYPE (decl) != object_type_node) + super_decl_type = object_type_node; + /* We're defining java.lang.Object */ + else + super_decl_type = NULL_TREE; + + /* Set super info and mark the class a complete */ + set_super_info (flags, TREE_TYPE (decl), super_decl_type, + ctxp->interface_number); + ctxp->interface_number = 0; + CLASS_COMPLETE_P (decl) = 1; + add_superinterfaces (decl, interfaces); + + return decl; +} + +/* Can't use lookup_field () since we don't want to load the class and + can't set the CLASS_LOADED_P flag */ + +static tree +find_field (class, name) + tree class; + tree name; +{ + tree decl; + for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl)) + { + if (DECL_NAME (decl) == name) + return decl; + } + return NULL_TREE; +} + +/* Wrap around lookup_field that doesn't potentially upset the value + of CLASS */ + +static tree +lookup_field_wrapper (class, name) + tree class, name; +{ + tree type = class; + return lookup_field (&type, name); +} + +/* Find duplicate field within the same class declarations and report + the error. Returns 1 if a duplicated field was found, 0 + otherwise. */ + +static int +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 (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)))) : + 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), + t2, IDENTIFIER_POINTER (DECL_NAME (decl)), + DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl)); + free (t1); + free (t2); + return 1; + } + return 0; +} + +/* Field registration routine. If TYPE doesn't exist, field + declarations are linked to the undefined TYPE dependency list, to + be later resolved in java_complete_class () */ + +static void +register_fields (flags, type, variable_list) + int flags; + tree type, variable_list; +{ + tree current, saved_type; + tree class_type = TREE_TYPE (ctxp->current_parsed_class); + int saved_lineno = lineno; + int must_chain = 0; + tree wfl = NULL_TREE; + + /* If we're adding fields to interfaces, those fields are public, + static, final */ + if (CLASS_INTERFACE (TYPE_NAME (class_type))) + { + OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK), + flags, ACC_PUBLIC, + "%s", "interface field(s)"); + OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK), + flags, ACC_STATIC, + "%s", "interface field(s)"); + OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK), + flags, ACC_FINAL, "%s", "interface field(s)"); + check_modifiers ("Illegal interface member modifier `%s'", flags, + INTERFACE_FIELD_MODIFIERS); + flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL); + } + + /* 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 */ + if (!must_chain && TREE_CODE (type) == RECORD_TYPE) + type = promote_type (type); + + for (current = variable_list, saved_type = type; current; + current = TREE_CHAIN (current), type = saved_type) + { + tree field_decl; + tree cl = TREE_PURPOSE (current); + tree init = TREE_VALUE (current); + tree current_name = EXPR_WFL_NODE (cl); + + /* Process NAME, as it may specify extra dimension(s) for it */ + type = build_array_from_name (type, wfl, current_name, ¤t_name); + + /* Check for redeclarations */ + if (duplicate_declaration_error_p (current_name, type, cl)) + continue; + + /* 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. */ + if (type != saved_type && !must_chain + && (TREE_CODE (type) == RECORD_TYPE)) + type = promote_type (type); + + /* Set lineno to the line the field was found and create a + declaration for it */ + lineno = EXPR_WFL_LINENO (cl); + field_decl = add_field (class_type, current_name, type, flags); + + /* 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 (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; + } + } + } + lineno = saved_lineno; +} + +/* 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; + + 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 (); + + /* Keep initialization in order to enforce 8.5 */ + ctxp->static_initialized = nreverse (ctxp->static_initialized); + + /* We process the list of assignment we produced as the result of + the declaration of initialized static field and add them as + statement to the <clinit> method. */ + for (c = ctxp->static_initialized; c; c = TREE_CHAIN (c)) + { + /* 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); + } + + BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block (); + exit_block (); + ctxp->static_initialized = NULL_TREE; +} + +/* Shared accros method_declarator and method_header to remember the + patch stage that was reached during the declaration of the method. + A method DECL is built differently is there is no patch + (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN) + pending on the currently defined method. */ + +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 */ + +static tree +method_header (flags, type, mdecl, throws) + int flags; + tree type, mdecl, throws; +{ + tree meth = TREE_VALUE (mdecl); + tree id = TREE_PURPOSE (mdecl); + tree this_class = TREE_TYPE (ctxp->current_parsed_class); + tree meth_name, returned_type, current; + int saved_lineno; + + 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) + { + 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))) + 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))); + } + + + /* Method declared within the scope of an interface are implicitly + abstract and public. Conflicts with other erroneously provided + modifiers are check right after. */ + + if (CLASS_INTERFACE (TYPE_NAME (this_class))) + { + /* If FLAGS isn't set because of a modifier, turn the + corresponding modifier WFL to NULL so we issue a warning on + the obsolete use of the modifier */ + if (!(flags & ACC_PUBLIC)) + MODIFIER_WFL (PUBLIC_TK) = NULL; + if (!(flags & ACC_ABSTRACT)) + MODIFIER_WFL (ABSTRACT_TK) = NULL; + flags |= ACC_PUBLIC; + flags |= ACC_ABSTRACT; + } + + /* Modifiers context reset moved up, so abstract method declaration + modifiers can be later checked. */ + + meth_name = EXPR_WFL_NODE (id); + + if (unresolved_type_p (type, &returned_type)) + { + 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); + } + } + else + TREE_TYPE (meth) = type; + + saved_lineno = lineno; + /* When defining an abstract or interface method, the curly + bracket at level 1 doesn't exist because there is no function + body */ + lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 : + EXPR_WFL_LINENO (id)); + + if (patch_stage) /* includes ret type and/or all args */ + { + jdep *jdep; + meth = add_method_1 (this_class, flags, meth_name, meth); + /* Patch for the return type */ + if (patch_stage == JDEP_METHOD_RETURN) + { + jdep = CLASSD_LAST (ctxp->classd_list); + JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth)); + } + /* This is the stop JDEP. METH allows the function's signature + to be computed. */ + register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE); + } + else + { + 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); + } + } + 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) + { + 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; + } + + /* 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. */ + if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node) + DECL_NAME (meth) = id; + return meth; +} + +/* Check modifiers that can be declared but exclusively */ + +static void +check_modifiers_consistency (flags) + int flags; +{ + int acc_count = 0; + tree cl = NULL_TREE; + + THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, 0, acc_count, cl); + THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, 1, acc_count, cl); + THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, 2, acc_count, cl); + if (acc_count > 1) + parse_error_context + (cl, "Inconsistent member declaration. At most one of `public', " + "`private', or `protected' may be specified"); +} + +/* Check the methode header METH for abstract specifics features */ + +static void +check_abstract_method_header (meth) + tree 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)); + + OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (ABSTRACT_TK), flags, + ACC_ABSTRACT, "abstract method `%s'", + IDENTIFIER_POINTER (name)); + OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK), flags, + ACC_PUBLIC, "abstract method `%s'", + IDENTIFIER_POINTER (name)); + + check_modifiers ("Illegal modifier `%s' for interface method", + flags, INTERFACE_METHOD_MODIFIERS); +} + +/* Create a FUNCTION_TYPE node and start augmenting it with the + declared function arguments. Arguments type that can't be resolved + are left as they are, but the returned node is marked as containing + incomplete types. */ + +static tree +method_declarator (id, list) + tree id, list; +{ + tree arg_types = NULL_TREE, current, node; + tree meth = make_node (FUNCTION_TYPE); + jdep *jdep; + + 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 already, arg_node; + tree type_wfl = NULL_TREE; + + /* 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; + + /* Check redefinition */ + for (already = arg_types; already; already = TREE_CHAIN (already)) + if (TREE_PURPOSE (already) == name) + { + parse_error_context + (wfl_name, "Variable `%s' is used more than once in the " + "argument list of method `%s'", IDENTIFIER_POINTER (name), + IDENTIFIER_POINTER (EXPR_WFL_NODE (id))); + break; + } + + /* If we've an incomplete argument type, we know there is a location + to patch when the type get resolved, later. */ + jdep = NULL; + if (must_chain) + { + 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); + 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); + node = build_tree_list (id, meth); + return node; +} + +static int +unresolved_type_p (wfl, returned) + tree wfl; + tree *returned; + +{ + if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION) + { + tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl)); + if (returned) + *returned = (decl ? TREE_TYPE (decl) : NULL_TREE); + return 1; + } + if (returned) + *returned = wfl; + return 0; +} + +/* From NAME, build a qualified identifier node using the + qualification from the current package definition. */ + +static tree +parser_qualified_classname (name) + tree name; +{ + if (ctxp->package) + return merge_qualified_name (ctxp->package, EXPR_WFL_NODE (name)); + else + return EXPR_WFL_NODE (name); +} + +/* Called once the type a interface extends is resolved. Returns 0 if + everything is OK. */ + +static int +parser_check_super_interface (super_decl, this_decl, this_wfl) + tree super_decl, this_decl, this_wfl; +{ + tree super_type = TREE_TYPE (super_decl); + + /* Has to be an interface */ + if (!CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (super_decl)))) + { + parse_error_context + (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'", + (TYPE_ARRAY_P (super_type) ? "array" : "class"), + IDENTIFIER_POINTER (DECL_NAME (super_decl)), + (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ? + "interface" : "class"), + IDENTIFIER_POINTER (DECL_NAME (this_decl))); + return 1; + } + + /* Check scope: same package OK, other package: OK if public */ + if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl))) + return 1; + + SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s", + IDENTIFIER_POINTER (DECL_NAME (this_decl)), + IDENTIFIER_POINTER (DECL_NAME (super_decl)))); + return 0; +} + +/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns + 0 if everthing is OK. */ + +static int +parser_check_super (super_decl, this_decl, wfl) + tree super_decl, this_decl, wfl; +{ + tree super_type = TREE_TYPE (super_decl); + + /* SUPER should be a CLASS (neither an array nor an interface) */ + if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type))) + { + parse_error_context + (wfl, "Class `%s' can't subclass %s `%s'", + IDENTIFIER_POINTER (DECL_NAME (this_decl)), + (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"), + IDENTIFIER_POINTER (DECL_NAME (super_decl))); + return 1; + } + + if (CLASS_FINAL (TYPE_NAME (super_type))) + { + parse_error_context (wfl, "Can't subclass final classes: %s", + IDENTIFIER_POINTER (DECL_NAME (super_decl))); + return 1; + } + + /* Check scope: same package OK, other package: OK if public */ + if (check_pkg_class_access (DECL_NAME (super_decl), wfl)) + return 1; + + SOURCE_FRONTEND_DEBUG (("Completing class %s with %s", + IDENTIFIER_POINTER (DECL_NAME (this_decl)), + IDENTIFIER_POINTER (DECL_NAME (super_decl)))); + return 0; +} + +/* Create a new dependency list and link it (in a LIFO manner) to the + CTXP list of type dependency list. */ + +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"); + + new->first = new->last = NULL; + new->next = ctxp->classd_list; + ctxp->classd_list = new; +} + +static jdeplist * +reverse_jdep_list (ctxp) + struct parser_ctxt *ctxp; +{ + register jdeplist *prev = NULL, *current, *next; + for (current = ctxp->classd_list; current; current = next) + { + next = current->next; + current->next = prev; + prev = current; + } + return prev; +} + +/* Create a fake pointer based on the ID stored in the WFL */ + +static tree +obtain_incomplete_type (wfl) + tree wfl; +{ + tree ptr; + tree name = EXPR_WFL_NODE (wfl); + + for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr)) + if (TYPE_NAME (TREE_PURPOSE (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); + pop_obstacks (); + TREE_CHAIN (ptr) = ctxp->incomplete_class; + ctxp->incomplete_class = ptr; + } + + return ptr; +} + +/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is + non NULL instead of computing a new fake type based on WFL. The new + dependency is inserted in the current type dependency list, in FIFO + manner. */ + +static tree +register_incomplete_type (kind, wfl, decl, ptr) + int kind; + tree wfl, decl, ptr; +{ + jdep *new = malloc (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); + + JDEP_KIND (new) = kind; + JDEP_DECL (new) = decl; + JDEP_SOLV (new) = ptr; + JDEP_WFL (new) = wfl; + JDEP_CHAIN (new) = NULL; + JDEP_MISC (new) = NULL_TREE; + JDEP_GET_PATCH (new) = (tree *)NULL; + + JDEP_INSERT (ctxp->classd_list, new); + + return ptr; +} + +void +java_check_circular_reference () +{ + tree current; + for (current = ctxp->class_list; current; current = TREE_CHAIN (current)) + { + tree type = TREE_TYPE (current); + if (CLASS_INTERFACE (TYPE_NAME (type))) + { + /* Check all interfaces this class extends */ + tree basetype_vec = TYPE_BINFO_BASETYPES (type); + int n, i; + + if (!basetype_vec) + return; + n = TREE_VEC_LENGTH (basetype_vec); + for (i = 0; i < n; i++) + { + tree vec_elt = TREE_VEC_ELT (basetype_vec, i); + if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node + && interface_of_p (type, BINFO_TYPE (vec_elt))) + parse_error_context (lookup_cl (current), + "Cyclic interface inheritance"); + } + } + else + if (inherits_from_p (CLASSTYPE_SUPER (type), type)) + parse_error_context (lookup_cl (current), + "Cyclic class inheritance"); + } +} + +void +safe_layout_class (class) + tree 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; + CLASS_LOADED_P (class) = 1; +} + +static tree +jdep_resolve_class (dep) + jdep *dep; +{ + tree decl; + + if (!JDEP_RESOLVED_P (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; + } + return decl; +} + +/* Complete unsatisfied class declaration and their dependencies */ + +void +java_complete_class () +{ + tree cclass; + jdeplist *cclassd; + int error_found; + tree type; + + push_obstacks (&permanent_obstack, &permanent_obstack); + + /* Process imports and reverse the import on demand list */ + process_imports (); + if (ctxp->import_demand_list) + ctxp->import_demand_list = nreverse (ctxp->import_demand_list); + + /* 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)) + { + jdep *dep; + for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep)) + { + tree decl; + + if (!(decl = jdep_resolve_class (dep))) + continue; + + /* Now it's time to patch */ + switch (JDEP_KIND (dep)) + { + case JDEP_SUPER: + /* Simply patch super */ + if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep))) + continue; + BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO + (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl); + break; + + case JDEP_FIELD: + { + /* We do part of the job done in add_field */ + tree field_decl = JDEP_DECL (dep); + tree field_type = TREE_TYPE (decl); + push_obstacks (&permanent_obstack, &permanent_obstack); + if (TREE_CODE (field_type) == RECORD_TYPE) + field_type = promote_type (field_type); + pop_obstacks (); + TREE_TYPE (field_decl) = field_type; + SOURCE_FRONTEND_DEBUG + (("Completed field/var decl `%s' with `%s'", + IDENTIFIER_POINTER (DECL_NAME (field_decl)), + IDENTIFIER_POINTER (DECL_NAME (decl)))); + break; + } + case JDEP_METHOD: /* We start patching a method */ + case JDEP_METHOD_RETURN: + error_found = 0; + while (1) + { + if (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 ? + "Completing fct `%s' with ret type `%s'": + "Completing arg `%s' with type `%s'"), + IDENTIFIER_POINTER (EXPR_WFL_NODE + (JDEP_DECL_WFL (dep))), + IDENTIFIER_POINTER (DECL_NAME (decl)))); + } + else + error_found = 1; + dep = JDEP_CHAIN (dep); + if (JDEP_KIND (dep) == JDEP_METHOD_END) + break; + else + decl = jdep_resolve_class (dep); + } + if (!error_found) + { + tree mdecl = JDEP_DECL (dep), signature; + push_obstacks (&permanent_obstack, &permanent_obstack); + /* Recompute and reset the signature */ + signature = build_java_signature (TREE_TYPE (mdecl)); + set_java_signature (TREE_TYPE (mdecl), signature); + pop_obstacks (); + } + else + continue; + break; + + case JDEP_INTERFACE: + if (parser_check_super_interface (decl, JDEP_DECL (dep), + JDEP_WFL (dep))) + continue; + parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep)); + break; + + case JDEP_PARM: + case JDEP_VARIABLE: + type = TREE_TYPE(decl); + if (TREE_CODE (type) == RECORD_TYPE) + type = promote_type (type); + JDEP_APPLY_PATCH (dep, type); + break; + + case JDEP_TYPE: + JDEP_APPLY_PATCH (dep, TREE_TYPE (decl)); + SOURCE_FRONTEND_DEBUG + (("Completing a random type dependency on a '%s' node", + tree_code_name [TREE_CODE (JDEP_DECL (dep))])); + break; + + case JDEP_EXCEPTION: + /* Check for righteous inheritance here */ + if (!inherits_from_p (TREE_TYPE (decl), throwable_type_node)) + { + parse_error_context + (JDEP_WFL (dep), "Class `%s' in `throws' clause must be " + "a subclass of class `java.lang.Throwable'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))); + } + else + { + JDEP_APPLY_PATCH (dep, TREE_TYPE (decl)); + SOURCE_FRONTEND_DEBUG + (("Completing `%s' `throws' argument node", + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))))); + } + break; + + default: + fatal ("Can't handle patch code %d - java_complete_class", + JDEP_KIND (dep)); + } + } + } + pop_obstacks (); + return; +} + +/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an + array. */ + +static tree +resolve_class (class_type, decl, cl) + tree class_type, decl, cl; +{ + char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type)); + char *base = name; + tree resolved_type, resolved_type_decl; + + /* 1- Check to see if we have an array. If true, find what we really + want to resolve */ + while (name[0] == '[') + name++; + if (base != name) + TYPE_NAME (class_type) = get_identifier (name); + + /* 2- Resolve the bare type */ + if (!(resolved_type_decl = do_resolve_class (class_type, decl, cl))) + return NULL_TREE; + resolved_type = TREE_TYPE (resolved_type_decl); + + /* 3- If we have and array, reconstruct the array down to its nesting */ + if (base != name) + { + while (base != name) + { + 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 + be returned. */ + resolved_type_decl = + build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type); + /* 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; + } + return resolved_type_decl; +} + +/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL + are used to report error messages. */ + +static tree +do_resolve_class (class_type, decl, cl) + tree class_type; + tree decl; + tree cl; +{ + tree new_class_decl; + tree original_name = NULL_TREE; + + /* Do not try to replace TYPE_NAME (class_type) by a variable, since + its is changed by find_in_imports{_on_demand} */ + + /* 1- Check for the type in single imports */ + if (find_in_imports (class_type)) + return NULL_TREE; + + /* 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)) && + !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl))) + load_class (TYPE_NAME (class_type), 0); + return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)); + } + + original_name = TYPE_NAME (class_type); + if (!QUALIFIED_P (TYPE_NAME (class_type)) && ctxp->package) + TYPE_NAME (class_type) = merge_qualified_name (ctxp->package, + TYPE_NAME (class_type)); + if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)))) + { + if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) && + !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl))) + load_class (TYPE_NAME (class_type), 0); + return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)); + } + TYPE_NAME (class_type) = original_name; + + /* 3- Check an other compilation unit that bears the name of type */ + load_class (TYPE_NAME (class_type), 0); + if (check_pkg_class_access (TYPE_NAME (class_type), + (cl ? cl : lookup_cl (decl)))) + return NULL_TREE; + + if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)))) + return new_class_decl; + + /* 4- Check the import on demands. Don't allow bar.baz to be + imported from foo.* */ + if (!QUALIFIED_P (TYPE_NAME (class_type))) + if (find_in_imports_on_demand (class_type)) + return NULL_TREE; + + /* 5- Last call for a resolution */ + return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type)); +} + +/* Resolve NAME and lay it out (if not done and if not the current + parsed class). Return a decl node. */ + +static tree +resolve_and_layout (name, cl) + tree name; + tree cl; +{ + tree decl = resolve_no_layout (name, cl); + if (decl && TREE_TYPE (decl) != current_class + && !CLASS_LOADED_P (TREE_TYPE (decl))) + safe_layout_class (TREE_TYPE (decl)); + return decl; +} + +/* Resolve a class, returns its decl but doesn't perform any + layout. The current parsing context is saved and restored */ + +static tree +resolve_no_layout (name, cl) + tree name, cl; +{ + tree ptr, decl; + BUILD_PTR_FROM_NAME (ptr, name); + java_parser_context_save_global (); + decl = resolve_class (ptr, NULL_TREE, cl); + java_parser_context_restore_global (); + + return decl; +} + +/* Called to report errors. Skip leader '[' in a complex array type + description that failed to be resolved. */ + +static char * +purify_type_name (name) + char *name; +{ + while (*name && *name == '[') + name++; + return name; +} + +/* The type CURRENT refers to can't be found. We print error messages. */ + +static void +complete_class_report_errors (dep) + jdep *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))), + 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))), + 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))), + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))), + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep)))); + break; + case JDEP_METHOD_RETURN: /* Covers return type */ + 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))), + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep)))); + break; + case JDEP_INTERFACE: + parse_error_context + (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found", + IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))), + (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")), + IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep)))); + break; + case JDEP_VARIABLE: + 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)))), + 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; + } +} + +/* Check uninitialized final. */ + +void +java_check_final () +{ +} + +static int +check_method_redefinition (class, method) + tree class, 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) + { + /* 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); + } + else + return 0; + + for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef)) + { + struct lang_type *t = TYPE_LANG_SPECIFIC (TREE_TYPE (redef)); + + if (! t || (redef == method)) + break; + if (DECL_NAME (redef) == name && sig == t->signature) + { + parse_error_context (cl, "Duplicate method declaration"); + return 1; + } + } + return 0; +} + +/* Check all the methods of CLASS. Methods are first completed then + checked according to regular method existance rules. + If no constructor were encountered, then build its declaration. */ + +static void +java_check_regular_methods (class_decl) + tree class_decl; +{ + tree method; + tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl)); + tree super_class = CLASSTYPE_SUPER (class); + int seen_constructor = 0; + + 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 method_wfl = DECL_NAME (method); + int aflags; + + if (DECL_CONSTRUCTOR_P (method)) + seen_constructor = 1; + + /* Check for redefinitions */ + if (check_method_redefinition (class, method)) + continue; + + sig = build_java_argument_signature (TREE_TYPE (method)); + + found = lookup_argument_method (super_class, DECL_NAME (method), sig); + + /* Nothing overrides or it's a private method */ + if (!found || (found && METHOD_PRIVATE (found))) + continue; + /* Can't override a method with the same name and different return + types. */ + if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method))) + { + 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)) + { + /* Static *can* override static */ + if (METHOD_STATIC (found) && METHOD_STATIC (method)) + continue; + parse_error_context + (method_wfl, + "%s methods can't be overriden. Method `%s' is %s in class `%s'", + (METHOD_FINAL (found) ? "Final" : "Static"), + lang_printable_name (found, 0), + (METHOD_FINAL (found) ? "final" : "static"), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + continue; + } + /* Static method can't override instance method. */ + if (METHOD_STATIC (method)) + { + parse_error_context + (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, 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)))) + { + 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, 0), + (METHOD_PUBLIC (found) ? "public" : "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))) + 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, 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)); + + if (!seen_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)); + DECL_CONSTRUCTOR_P (decl) = 1; + lineno = saved_lineno; + } +} + +/* 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; + + for (mthrows = DECL_FUNCTION_THROWS (method); + mthrows; mthrows = TREE_CHAIN (mthrows)) + { + /* We don't verify unchecked expressions */ + if (IS_UNCHECKED_EXPRESSION_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; +{ + int i, n; + tree method, basetype_vec, found; + + for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (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 (FIXME) */ + found = lookup_java_interface_method2 (interface, method); + if (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); + continue; + } + } + + /* 4- Inherited methods can't differ by their returned types */ + if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface))) + return; + n = TREE_VEC_LENGTH (basetype_vec); + for (i = 0; i < n; i++) + { + tree sub_interface_method, sub_interface; + tree vec_elt = TREE_VEC_ELT (basetype_vec, i); + if (!vec_elt) + continue; + sub_interface = BINFO_TYPE (vec_elt); + for (sub_interface_method = TYPE_METHODS (sub_interface); + sub_interface_method; + sub_interface_method = TREE_CHAIN (sub_interface_method)) + { + 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, 0), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (sub_interface_method)))), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found))))); + } + } +} + +/* 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. */ + +static tree +lookup_java_interface_method2 (class, method_decl) + tree class, method_decl; +{ + int i, n; + tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return; + + if (!basetype_vec) + return NULL_TREE; + + n = TREE_VEC_LENGTH (basetype_vec); + for (i = 0; i < n; i++) + { + tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return; + if ((BINFO_TYPE (vec_elt) != object_type_node) + && (to_return = + lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1))) + return to_return; + } + for (i = 0; i < n; i++) + { + to_return = lookup_java_interface_method2 + (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl); + if (to_return) + return to_return; + } + + return NULL_TREE; +} + +/* Lookup method using their name and partial signature. Return a + matching method only if their types differ. */ + +static tree +lookup_java_method2 (clas, method_decl, do_interface) + tree clas, method_decl; + int do_interface; +{ + tree method, method_signature, method_name, method_type; + method_signature = build_java_argument_signature (TREE_TYPE (method_decl)); + method_name = DECL_NAME (method_decl); + method_type = TREE_TYPE (TREE_TYPE (method_decl)); + + while (clas != NULL_TREE) + { + for (method = TYPE_METHODS (clas); + method != NULL_TREE; method = TREE_CHAIN (method)) + { + tree method_sig = build_java_argument_signature (TREE_TYPE (method)); + if (DECL_NAME (method) == method_name + && method_sig == method_signature + && TREE_TYPE (TREE_TYPE (method)) != method_type) + { + return method; + } + } + clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas)); + } + return NULL_TREE; +} + +/* Return the line that matches DECL line number. Used during error + report */ + +static tree +lookup_cl (decl) + tree decl; +{ + static tree cl = NULL_TREE; + + if (!decl) + return NULL_TREE; + + if (cl == NULL_TREE) + cl = build_expr_wfl (NULL_TREE, NULL, 0, 0); + + EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl)); + EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1); + + return cl; +} + +/* Look for a simple name in the single-type import list */ + +static tree +find_name_in_single_imports (name) + tree name; +{ + tree node; + + for (node = ctxp->import_list; node; node = TREE_CHAIN (node)) + if (TREE_VALUE (node) == name) + return (EXPR_WFL_NODE (TREE_PURPOSE (node))); + + return NULL_TREE; +} + +/* Process all single-type import. */ + +static int +process_imports () +{ + tree import; + int error_found; + + for (import = ctxp->import_list; import; import = TREE_CHAIN (import)) + { + tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import)); + + /* Don't load twice something already defined. */ + if (IDENTIFIER_CLASS_VALUE (to_be_found)) + continue; + QUALIFIED_P (to_be_found) = 1; + load_class (to_be_found, 0); + error_found = + check_pkg_class_access (to_be_found, TREE_PURPOSE (import)); + if (!IDENTIFIER_CLASS_VALUE (to_be_found)) + { + parse_error_context (TREE_PURPOSE (import), + "Class or interface `%s' not found in import", + IDENTIFIER_POINTER (to_be_found)); + return 1; + } + if (error_found) + return 1; + } + return 0; +} + +/* Possibly find a class imported by a single-type import statement. Return + 1 if an error occured, 0 otherwise. */ + +static int +find_in_imports (class_type) + tree class_type; +{ + tree import; + + for (import = ctxp->import_list; import; import = TREE_CHAIN (import)) + if (TREE_VALUE (import) == TYPE_NAME (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; +{ + 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)); + } + } + 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); + } + } + *returned_name = NULL; + return 0; + } +} + +/* Read a import directory, gathering potential match for further type + references. Indifferently reads a filesystem or a ZIP archive + directory. */ + +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; + DIR *dirp = NULL; + JCF jcfr, *jcf, *saved_jcf = current_jcf; + char *founddirname, *d_name; + + 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); + + else if (founddirname) + dirp = opendir (founddirname); + + if (!founddirname && !dirp) + { + static int first = 1; + if (first) + { + char buffer [256]; + sprintf (buffer, "Can't find default package `%s'. Check " + "the CLASSPATH environment variable and the access to the " + "archives.", name); + error (buffer); + java_error_count++; + first = 0; + } + else + parse_error_context (wfl, "Package `%s' not found in import", 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; + + 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; +} + +/* Possibly find a type in the import on demands specified + types. Returns 1 if an error occured, 0 otherwise. Run throught the + entire list, to detected potential double definitions. */ + +static int +find_in_imports_on_demand (class_type) + tree class_type; +{ + tree node, import, node_to_use; + int seen_once = -1; + tree cl; + + for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import)) + { + char *id_name; + 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_grow0 (&temporary_obstack, + IDENTIFIER_POINTER (TYPE_NAME (class_type)), + IDENTIFIER_LENGTH (TYPE_NAME (class_type))); + id_name = obstack_finish (&temporary_obstack); + + node = maybe_get_identifier (id_name); + if (node && IS_A_CLASSFILE_NAME (node)) + { + if (seen_once < 0) + { + cl = TREE_PURPOSE (import); + seen_once = 1; + node_to_use = node; + } + else + { + seen_once++; + parse_error_context + (import, "Type `%s' also potentially defined in package `%s'", + IDENTIFIER_POINTER (TYPE_NAME (class_type)), + IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import)))); + } + } + } + + if (seen_once == 1) + { + /* Setup lineno so that it refers to the line of the import (in + case we parse a class file and encounter errors */ + 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), + "", '/', '.', ""); + 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 + loaded and not seen in source yet, the load */ + if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl)) + && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl)))) + load_class (node_to_use, 0); + lineno = saved_lineno; + return check_pkg_class_access (TYPE_NAME (class_type), cl); + } + else + return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */ +} + +/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no + access violations were found, 1 otherwise. */ + +static int +check_pkg_class_access (class_name, cl) + tree class_name; + tree cl; +{ + tree type; + + if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name)) + return 0; + + if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name)))) + return 0; + + if (!CLASS_PUBLIC (TYPE_NAME (type))) + { + parse_error_context + (cl, "Can't access %s `%s'. Only public classes and interfaces in " + "other packages can be accessed", + (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"), + IDENTIFIER_POINTER (class_name)); + return 1; + } + return 0; +} + +/* Local variable declaration. */ + +static void +declare_local_variables (modifier, type, vlist) + int modifier; + tree type; + tree vlist; +{ + 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 + pushed a block and now. Keep a cound of block to close */ + if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl))) + { + tree body = DECL_FUNCTION_BODY (current_function_decl); + tree b = enter_block (); + 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; + } + + /* 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 */ + if (!must_chain && TREE_CODE (type) == RECORD_TYPE) + type = promote_type (type); + + /* Go through all the declared variables */ + for (current = vlist, saved_type = type; current; + current = TREE_CHAIN (current), type = saved_type) + { + tree other; + tree wfl = TREE_PURPOSE (current); + tree name = EXPR_WFL_NODE (wfl); + tree init = TREE_VALUE (current); + + /* Process NAME, as it may specify extra dimension(s) for it */ + type = build_array_from_name (type, type_wfl, name, &name); + + /* Variable redefinition check */ + if ((other = lookup_name_in_blocks (name))) + { + variable_redefinition_error (wfl, name, TREE_TYPE (other), + DECL_SOURCE_LINE (other)); + continue; + } + + /* 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. */ + if (type != saved_type && !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); + + /* 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")); +} + +/* Called during parsing. Build decls from argument list. */ + +static void +source_start_java_method (fndecl) + tree fndecl; +{ + tree tem; + tree parm_decl; + int i; + + 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++) + { + 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 (INCOMPLETE_TYPE_P (type)) + { + jdep *jdep; + parm_decl = build_decl_no_layout (PARM_DECL, name, type); + + register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type); + jdep = CLASSD_LAST (ctxp->classd_list); + JDEP_MISC (jdep) = name; + JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl); + } + else + parm_decl = build_decl (PARM_DECL, name, type); + + BLOCK_CHAIN_DECL (parm_decl); + } + tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)); + BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) = + nreverse (tem); + DECL_ARG_SLOT_COUNT (current_function_decl) = i; +} + +/* Called during expansion. Push decls formerly built from argument + list so they're usable during expansion. */ + +static void +expand_start_java_method (fndecl) + tree fndecl; +{ + tree tem, *ptr; + + current_function_decl = fndecl; + + announce_function (fndecl); + pushlevel (1); /* Push parameters */ + ptr = &DECL_ARGUMENTS (fndecl); + tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)); + while (tem) + { + tree next = TREE_CHAIN (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; + } + *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. */ + +static void +source_end_java_method () +{ + tree fndecl = current_function_decl; + + 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) + expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))); + + /* pop out of its parameters */ + pushdecl_force_head (DECL_ARGUMENTS (fndecl)); + poplevel (1, 0, 1); + BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; + + /* Generate rtl for function exit. */ + 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. */ + rest_of_compilation (fndecl); + } + + current_function_decl = NULL_TREE; + /* permanent_allocation (1); */ + java_parser_context_restore_global (); +} + +/* Record EXPR in the current function block. Complements compound + expression second operand if necessary. */ + +tree +java_method_add_stmt (fndecl, expr) + tree fndecl, expr; +{ + return add_stmt_to_block (DECL_FUNCTION_BODY (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 ((c = add_stmt_to_compound (body, type, stmt)) == body) + return body; + + BLOCK_EXPR_BODY (b) = c; + TREE_SIDE_EFFECTS (c) = 1; + return c; +} + +/* Add STMT to EXISTING if possible, otherwise create a new + COMPOUND_EXPR and add STMT to it. */ + +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); + else + node = build (COMPOUND_EXPR, type, stmt, size_zero_node); + + return node; +} + +/* Hold THIS for the scope of the current public method decl. */ +static tree current_this; + +/* Layout all class found during parsing */ + +void +java_layout_classes () +{ + tree current; + for (current = ctxp->class_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); + } +} + +/* Expand all methods in all registered classes. */ + +void +java_complete_expand_methods () +{ + tree current; + + for (current = ctxp->class_list; current; current = TREE_CHAIN (current)) + { + tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current)); + tree decl; + + current_class = TREE_TYPE (current); + + /* Initialize a new constant pool */ + init_outgoing_cpool (); + + /* 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)) + { + current_function_decl = decl; + /* Don't generate debug info on line zero when expanding a + generated constructor. */ + if (DECL_CONSTRUCTOR_P (decl) && !DECL_FUNCTION_BODY (decl)) + { + /* If we found errors, it's too dangerous to try to generate + and expand a constructor */ + if (!java_error_count) + { + restore_line_number_status (1); + java_complete_expand_method (decl); + restore_line_number_status (0); + } + } + else + java_complete_expand_method (decl); + } + + /* Make the class data, register it and run the rest of decl + compilation on it */ + if (!java_error_count && ! flag_emit_class_files) + { + make_class_data (current_class); + register_class (); + rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0); + } + } +} + +/* 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; +{ + 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; + } + + if (DECL_FUNCTION_BODY (mdecl)) + { + expand_start_java_method (mdecl); + + current_this + = (!METHOD_STATIC (mdecl) ? + BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE); + + /* Purge the `throws' list of unchecked exceptions */ + purge_unchecked_exceptions (mdecl); + + /* Install exceptions thrown with `throws' */ + PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl)); + + if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) && no_ac_found) + java_complete_tree (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl))); + /* Don't go any further if we've found error(s) during the + expansion */ + if (!java_error_count) + source_end_java_method (); + + /* Pop the exceptions and sanity check */ + POP_EXCEPTIONS(); + if (currently_caught_type_list) + fatal ("Exception list non empty - java_complete_expand_method"); + } +} + +/* Expand finals. */ + +void +java_expand_finals () +{ +} + +/* 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 + separating `.' operator. */ + +static tree +make_qualified_primary (primary, right, location) + tree primary, right; + int location; +{ + tree wfl; + + /* 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) == THIS_EXPR) + { + wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0); + EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary); + wfl = make_qualified_name (wfl, right, location); + PRIMARY_P (wfl) = 1; + return wfl; + } + /* Other non WFL node are wrapped around a WFL */ + else if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION) + { + wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0); + EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary); + EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (primary, NULL_TREE); + } + else + { + wfl = primary; + if (!EXPR_WFL_QUALIFICATION (primary)) + EXPR_WFL_QUALIFICATION (primary) = + build_tree_list (primary, NULL_TREE); + } + + EXPR_WFL_LINECOL (right) = location; + chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE)); + PRIMARY_P (wfl) = 1; + return wfl; +} + +/* Simple merge of two name separated by a `.' */ + +static tree +merge_qualified_name (left, right) + tree left, right; +{ + tree node; + obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left), + IDENTIFIER_LENGTH (left)); + obstack_1grow (&temporary_obstack, '.'); + obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right), + IDENTIFIER_LENGTH (right)); + node = get_identifier (obstack_base (&temporary_obstack)); + obstack_free (&temporary_obstack, obstack_base (&temporary_obstack)); + QUALIFIED_P (node) = 1; + return node; +} + +/* Merge the two parts of a qualified name into LEFT. Set the + location information of the resulting node to LOCATION, usually + inherited from the location information of the `.' operator. */ + +static tree +make_qualified_name (left, right, location) + tree left, right; + int location; +{ + tree left_id = EXPR_WFL_NODE (left); + tree right_id = EXPR_WFL_NODE (right); + tree wfl, merge; + + merge = merge_qualified_name (left_id, right_id); + + /* Left wasn't qualified and is now qualified */ + if (!QUALIFIED_P (left_id)) + { + tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0); + EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left); + EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE); + } + + wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0); + EXPR_WFL_LINECOL (wfl) = location; + chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE)); + + EXPR_WFL_NODE (left) = merge; + return left; +} + +/* Extract the last identifier component of the qualified in WFL. The + last identifier is removed from the linked list */ + +static tree +cut_identifier_in_qualified (wfl) + tree wfl; +{ + tree q; + tree previous = NULL_TREE; + for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q)) + if (!TREE_CHAIN (q)) + { + if (!previous) + fatal ("Operating on a non qualified qualified WFL - " + "cut_identifier_in_qualified"); + TREE_CHAIN (previous) = NULL_TREE; + return TREE_PURPOSE (q); + } +} + +/* Resolve the expression name NAME. Return its decl. */ + +static tree +resolve_expression_name (id) + tree id; +{ + tree name = EXPR_WFL_NODE (id); + tree decl; + + /* 6.5.5.1: Simple expression names */ + if (!PRIMARY_P (id) && !QUALIFIED_P (name)) + { + /* 15.13.1: NAME can appear within the scope of a local variable + declaration */ + if ((decl = IDENTIFIER_LOCAL_VALUE (name))) + return decl; + + /* 15.13.1: NAME can appear within a class declaration */ + else + { + decl = lookup_field_wrapper (current_class, name); + if (decl) + { + int fs = FIELD_STATIC (decl); + /* Instance variable (8.3.1.1) can't appear within + static method, static initializer or initializer for + a static variable. */ + if (!fs && METHOD_STATIC (current_function_decl)) + { + parse_error_context + (id, "Can't make a static reference to nonstatic variable " + "`%s' in class `%s'", + IDENTIFIER_POINTER (name), + IDENTIFIER_POINTER (DECL_NAME + (TYPE_NAME (current_class)))); + return error_mark_node; + } + decl = build_field_ref ((fs ? NULL_TREE : current_this), + current_class, name); + return (fs ? build_class_init (current_class, decl) : decl); + } + /* Fall down to error report on undefined variable */ + } + } + /* 6.5.5.2 Qualified Expression Names */ + else + { + qualify_ambiguous_name (id); + /* 15.10.1 Field Access Using a Primary and/or Expression Name */ + /* 15.10.2: Accessing Superclass Members using super */ + return resolve_field_access (id, NULL, NULL); + } + + /* We've got an error here */ + parse_error_context (id, "Undefined variable `%s'", + IDENTIFIER_POINTER (name)); + + return error_mark_node; +} + +/* 15.10.1 Field Acess Using a Primary and/or Expression Name. + We return something suitable to generate the field access. We also + return the field decl in FIELD_DECL and its type in FIELD_TYPE. If + recipient's address can be null. */ + +static tree +resolve_field_access (qual_wfl, field_decl, field_type) + tree qual_wfl; + tree *field_decl, *field_type; +{ + int is_static = 0; + tree field_ref; + tree decl, where_found, type_found; + + if (resolve_qualified_expression_name (qual_wfl, &decl, + &where_found, &type_found)) + return error_mark_node; + + /* Resolve the LENGTH field of an array here */ + if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found) + && ! flag_emit_class_files) + { + tree length = build_java_array_length_access (where_found); + field_ref = + build_java_arraynull_check (type_found, length, int_type_node); + } + /* 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) + 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)); + if (field_ref == error_mark_node) + return error_mark_node; + if (is_static) + { + 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) + { + tree type = QUAL_DECL_TYPE (field_ref); + field_ref = build (COMPOUND_EXPR, type, where_found, field_ref); + } + } + } + else + field_ref = decl; + + if (field_decl) + *field_decl = decl; + if (field_type) + *field_type = QUAL_DECL_TYPE (decl); + return field_ref; +} + +/* 6.5.5.2: Qualified Expression Names */ + +static int +resolve_qualified_expression_name (wfl, found_decl, where_found, type_found) + tree wfl; + tree *found_decl, *type_found, *where_found; +{ + int from_type = 0; /* Field search initiated from a type */ + int from_super = 0, from_cast = 0; + int previous_call_static = 0; + int is_static; + tree decl = NULL_TREE, type = NULL_TREE, q; + *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 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)) + { + decl = maybe_access_field (decl, *where_found, type); + if (decl == error_mark_node) + return 1; + } + /* And code for the function call */ + if (complete_function_arguments (qual_wfl)) + return 1; + *where_found = + patch_method_invocation_stmt (qual_wfl, decl, type, + &is_static, NULL); + if (*where_found == error_mark_node) + return 1; + *type_found = type = QUAL_DECL_TYPE (*where_found); + + /* If the previous call was static and this one is too, + build a compound expression to hold the two (because in + that case, previous function calls aren't transported as + forcoming function's argument. */ + if (previous_call_static && is_static) + { + decl = build (COMPOUND_EXPR, type, decl, *where_found); + TREE_SIDE_EFFECTS (decl) = 1; + } + else + { + previous_call_static = is_static; + decl = *where_found; + } + continue; + + case CONVERT_EXPR: + *where_found = decl = java_complete_tree (qual_wfl); + if (decl == error_mark_node) + return 1; + *type_found = type = QUAL_DECL_TYPE (decl); + from_cast = 1; + 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)) + { + decl = maybe_access_field (decl, *where_found, type); + if (decl == error_mark_node) + return 1; + } + /* And code for the array reference expression */ + decl = java_complete_tree (qual_wfl); + if (decl == error_mark_node) + 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. */ + previous_call_static = 0; + + /* It can be the keyword THIS */ + if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node) + { + if (!current_this) + { + parse_error_context + (wfl, "Keyword `this' used outside allowed context"); + return 1; + } + /* We have to generate code for intermediate acess */ + *where_found = decl = current_this; + type = QUAL_DECL_TYPE (decl); + continue; + } + + /* 15.10.2 Accessing Superclass Members using SUPER */ + if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node) + { + tree node; + /* Check on the restricted use of SUPER */ + if (METHOD_STATIC (current_function_decl) + || current_class == object_type_node) + { + parse_error_context + (wfl, "Keyword `super' used outside allowed context"); + return 1; + } + /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */ + node = build_cast (EXPR_WFL_LINECOL (qual_wfl), + CLASSTYPE_SUPER (current_class), + build_this (EXPR_WFL_LINECOL (qual_wfl))); + *where_found = decl = java_complete_tree (node); + *type_found = type = QUAL_DECL_TYPE (decl); + from_super = from_type = 1; + continue; + } + + /* 15.13.1: Can't search for field name in packages, so we + 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, 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 + expression was qualified. */ + else if (RESOLVE_TYPE_NAME_P (qual_wfl)) + { + if (!(decl = QUAL_RESOLUTION (q))) + return 1; /* Error reported already */ + + if (not_accessible_p (TREE_TYPE (decl), decl, 0)) + { + 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))), + IDENTIFIER_POINTER (DECL_NAME (decl)), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)))); + return 1; + } + + type = TREE_TYPE (decl); + from_type = 1; + } + /* We resolve and expression name */ + else + { + tree field_decl; + + /* If there exists an early resolution, use it. That occurs + only once and we know that there are more things to + 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); + *type_found = type; + } + + /* 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. */ + else + { + int is_static; + 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, 0), + IDENTIFIER_POINTER (DECL_NAME (field_decl))); + return 1; + } + + if (!(field_decl = + lookup_field_wrapper (type, EXPR_WFL_NODE (qual_wfl)))) + { + parse_error_context + (qual_wfl, "No variable `%s' defined in class `%s'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); + return 1; + } + + /* Check on accessibility here */ + if (not_accessible_p (type, field_decl, from_super)) + { + parse_error_context + (qual_wfl, + "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))), + IDENTIFIER_POINTER (DECL_NAME (field_decl)), + IDENTIFIER_POINTER + (DECL_NAME (TYPE_NAME (current_class)))); + return 1; + } + + /* There are things to check when fields are accessed + from type. There are no restrictions on a static + declaration of the field when it is accessed from an + interface */ + is_static = FIELD_STATIC (field_decl); + if (!from_super && from_type + && !TYPE_INTERFACE_P (type) && !is_static) + { + parse_error_context + (qual_wfl, "Can't make a static reference to nonstatic " + "variable `%s' in class `%s'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); + return 1; + } + 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 (!is_static) + { + decl = maybe_access_field (decl, *where_found, *type_found); + if (decl == error_mark_node) + return 1; + } + + /* We want to keep the location were found it, and the type + we found. */ + *where_found = decl; + *type_found = type; + + /* This is the decl found and eventually the next one to + search from */ + decl = field_decl; + } + from_type = 0; + type = QUAL_DECL_TYPE (decl); + } + } + *found_decl = decl; + return 0; +} + +/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl) + can't be accessed from REFERENCE (a record type). */ + +int not_accessible_p (reference, member, from_super) + tree reference, member; + int from_super; +{ + int access_flag = get_access_flags_from_decl (member); + + /* Access always granted for members declared public */ + if (access_flag & ACC_PUBLIC) + return 0; + + /* Check access on protected members */ + if (access_flag & ACC_PROTECTED) + { + /* Access granted if it occurs from within the package + containing the class in which the protected member is + declared */ + 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; + + /* 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*/ + + if (access_flag & ACC_PRIVATE) + return (current_class == DECL_CONTEXT (member) ? 0 : 1); + + /* Default access are permitted only when occuring within the + package in which the type (REFERENCE) is declared. In other words, + REFERENCE is defined in the current package */ + if (ctxp->package) + return !class_in_current_package (reference); + + /* Otherwise, access is granted */ + return 0; +} + +/* Returns 1 if class was declared in the current package, 0 otherwise */ + +static int +class_in_current_package (class) + tree class; +{ + static tree cache = NULL_TREE; + int qualified_flag; + tree left; + + if (cache == class) + return 1; + + qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class))); + + /* If the current package is empty and the name of CLASS is + 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)) + return 0; + + /* If there is not package and the name of CLASS isn't qualified, + they belong to the same unnamed package */ + if (!ctxp->package && !qualified_flag) + return 1; + + /* Compare the left part of the name of CLASS with the package name */ + breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class))); + if (ctxp->package == left) + { + cache = class; + return 1; + } + return 0; +} + +/* This function may generate code to access DECL from WHERE. This is + done only if certain conditions meet. */ + +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))) + decl = build_field_ref (where ? where : current_this, + (type ? type : DECL_CONTEXT (decl)), + DECL_NAME (decl)); + return decl; +} + +/* Build a method invocation statement, 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, 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; + + /* Should be overriden if everything goes well. Otherwise, if + something fails, it should keep this value. It stop the + evaluation of a bogus assignment. See java_complete_tree, + MODIFY_EXPR: for the reasons why we sometimes want to keep on + evaluating an assignment */ + TREE_TYPE (patch) = error_mark_node; + + /* Since lookup functions are messing with line numbers, save the + context now. */ + java_parser_context_save_global (); + + /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */ + + /* Resolution of qualified name, excluding constructors */ + if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch)) + { + tree class_decl, identifier, identifier_wfl; + /* Extract the last IDENTIFIER of the qualified + expression. This is a wfl and we will use it's location + data during error report. */ + identifier_wfl = cut_identifier_in_qualified (wfl); + identifier = EXPR_WFL_NODE (identifier_wfl); + + /* Given the context, IDENTIFIER is syntactically qualified + as a MethodName. We need to qualify what's before */ + qualify_ambiguous_name (wfl); + + /* Package resolution are erroneous */ + if (RESOLVE_PACKAGE_NAME_P (wfl)) + { + tree remainder; + breakdown_qualified (&remainder, NULL, EXPR_WFL_NODE (wfl)); + parse_error_context (wfl, "Can't search method `%s' in package " + "`%s'",IDENTIFIER_POINTER (identifier), + IDENTIFIER_POINTER (remainder)); + PATCH_METHOD_RETURN_ERROR (); + } + /* We're resolving a call from a type */ + else if (RESOLVE_TYPE_NAME_P (wfl)) + { + tree decl = QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl)); + tree name = DECL_NAME (decl); + tree type; + + class_decl = resolve_and_layout (name, wfl); + if (CLASS_INTERFACE (decl)) + { + parse_error_context + (identifier_wfl, "Can't make static reference to method " + "`%s' in interface `%s'", IDENTIFIER_POINTER (identifier), + IDENTIFIER_POINTER (name)); + PATCH_METHOD_RETURN_ERROR (); + } + /* Look the method up in the type selector. The method ought + to be static. */ + type = TREE_TYPE (class_decl); + list = lookup_method_invoke (0, wfl, type, identifier, args); + if (list && !METHOD_STATIC (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)), 0), + fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); + free (fct_name); + PATCH_METHOD_RETURN_ERROR (); + } + } + /* We're resolving an expression name */ + else + { + tree field, type; + + /* 1- Find the field to which the call applies */ + field = resolve_field_access (wfl, NULL, &type); + if (field == error_mark_node) + PATCH_METHOD_RETURN_ERROR (); + + /* 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); + + /* 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, nreverse (args)); + } + + /* 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); + wfl = identifier_wfl; + } + /* Resolution of simple names, names generated after a primary: or + constructors */ + else + { + tree class_to_search; + int lc; /* Looking for Constructor */ + + /* 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) + { + 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 */ + if (CLASS_ABSTRACT (class_to_search)) + { + 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); + lc = 1; + } + /* This is a regular search in the local class, unless an + alternate class is specified. */ + else + { + class_to_search = (where ? where : current_class); + lc = 0; + } + + /* NAME is a simple identifier or comes from a primary. Search + in the class whose declaration contain the method being + invoked. */ + 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) + 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)) + PATCH_METHOD_RETURN_ERROR (); + + /* 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. */ + args = nreverse (args); + if (!CALL_CONSTRUCTOR_P (patch) && !METHOD_STATIC (list)) + args = tree_cons (NULL_TREE, primary ? primary : current_this, args); + + class_type = class_to_search; + } + + /* Merge point of all resolution schemes. If we have nothing, this + is an error, already signaled */ + 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)) + { + 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)), 0), + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))), fct_name, + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)))); + free (fct_name); + PATCH_METHOD_RETURN_ERROR (); + } + + if (is_static) + *is_static = METHOD_STATIC (list); + java_parser_context_restore_global (); + /* Sometimes, we want the decl of the selected method. Such as for + EH checking */ + if (ret_decl) + *ret_decl = list; + return patch_invoke (patch, list, args); +} + +/* Check that we're not trying to do a static reference to a method in + non static method. Return 1 if it's the case, 0 otherwise. */ + +static int +check_for_static_method_reference (wfl, node, method, where, primary) + tree wfl, node, method, where, primary; +{ + if (METHOD_STATIC (current_function_decl) + && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node)) + { + 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)), 0), fct_name, + IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where)))); + free (fct_name); + return 1; + } + return 0; +} + +/* Patch an invoke expression METHOD and ARGS, based on its invocation + mode. */ + +static tree +patch_invoke (patch, method, args) + tree patch, method, args; +{ + int im; + tree dtable, func; + tree signature = build_java_signature (TREE_TYPE (method)); + tree original_call, t, ta; + + /* Last step for args: convert build-in types */ + for (t = TYPE_ARG_TYPES (TREE_TYPE (method)), + ta = args; t && 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)); + + switch ((im = invocation_mode (method, 0))) + { + 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); + break; + + default: + fatal ("Unknown invocation mode - build_invoke"); + return NULL_TREE; + } + + /* 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)) + { + tree class = DECL_CONTEXT (method); + tree c1, saved_new, size, new; + if (!TYPE_SIZE (class)) + safe_layout_class (class); + size = size_in_bytes (class); + new = build (CALL_EXPR, promote_type (class), + build_address_of (alloc_object_node), + tree_cons (NULL_TREE, build_class_ref (class), + build_tree_list (NULL_TREE, + size_in_bytes (class))), + NULL_TREE); + saved_new = save_expr (new); + c1 = build_tree_list (NULL_TREE, saved_new); + TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1); + TREE_OPERAND (original_call, 1) = c1; + TREE_SET_CODE (original_call, CALL_EXPR); + patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new); + } + return patch; +} + +static int +invocation_mode (method, super) + tree method; + int super; +{ + int access = get_access_flags_from_decl (method); + + if (access & ACC_STATIC || access & ACC_FINAL) + 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. It covers the step + 15.11.2 (Compile-Time Step 2) */ + +static tree +lookup_method_invoke (lc, cl, class, name, arg_list) + int lc; + tree cl; + tree class, name, arg_list; +{ + tree method = make_node (FUNCTION_TYPE); + tree arg_type_list = NULL_TREE; + tree signature, list, node; + char *candidates; /* Used for error report */ + + for (node = arg_list; node; node = TREE_CHAIN (node)) + { + tree current_arg = TREE_TYPE (TREE_VALUE (node)); + if (TREE_CODE (current_arg) == RECORD_TYPE) + current_arg = promote_type (current_arg); + arg_type_list = tree_cons (NULL_TREE, current_arg, arg_type_list); + } + TYPE_ARG_TYPES (method) = arg_type_list; + + if (!lc) + { + list = find_applicable_accessible_methods_list (class, name, + arg_type_list); + list = find_most_specific_methods_list (list); + } + else + { + TREE_TYPE (method) = void_type_node; + signature = build_java_signature (method); + list = lookup_java_constructor (class, signature); + } + + if (lc && list) + return list; + if (list && !TREE_CHAIN (list)) + return TREE_VALUE (list); + + /* 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) + { + 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; + signature = build_java_argument_signature (TREE_TYPE (cm)); + sprintf + (string, " `%s(%s)' in `%s'%s", + IDENTIFIER_POINTER (name), + IDENTIFIER_POINTER (signature), + 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 */ + signature = build_java_argument_signature (method); + parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'%s", + 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 */ + +static tree +find_applicable_accessible_methods_list (class, name, arglist) + tree class, name, arglist; +{ + tree method; + tree list = NULL_TREE, all_list = NULL_TREE; + + while (class != NULL_TREE) + { + for (method = TYPE_METHODS (class); + method != NULL_TREE; method = TREE_CHAIN (method)) + { + /* Names have to match and we're not looking for constructor */ + if (DECL_NAME (method) != name + || DECL_CONSTRUCTOR_P (method)) + continue; + + if (argument_types_convertible (method, arglist)) + { + /* Retain accessible methods only */ + if (!not_accessible_p (class, method, 0)) + list = tree_cons (NULL_TREE, method, list); + else + /* Also retain all selected method here */ + all_list = tree_cons (NULL_TREE, method, list); + } + } + class = CLASSTYPE_SUPER (class); + } + /* Either return the list obtained or all selected (but + inaccessible) methods for better error report. */ + return (!list ? all_list : list); +} + +/* 15.11.2.2 Choose the Most Specific Method */ + +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 method; + DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0; + + for (method = list; method; method = TREE_CHAIN (method)) + { + /* 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)))) + { + int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current)); + max = (v > max ? v : max); + } + } + } + + /* 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) + { + 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; + } + + return new_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 int +argument_types_convertible (m1, m2_or_arglist) + tree m1, m2_or_arglist; +{ + static tree m2_arg_value = NULL_TREE; + static tree m2_arg_cache = NULL_TREE; + + register tree m1_arg, m2_arg; + + m1_arg = TYPE_ARG_TYPES (TREE_TYPE (m1)); + if (!METHOD_STATIC (m1)) + m1_arg = TREE_CHAIN (m1_arg); + + 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; + + m2_arg_value = m2_or_arglist; + m2_arg_cache = m2_arg; + } + + while (m1_arg && m2_arg) + { + 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); + } + return (!m1_arg && !m2_arg ? 1 : 0); +} + +/* Qualification routines */ + +static void +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; + + /* We first qualify the first element, then derive qualification of + others based on the first one. If the first element is qualified + by a resolution (field or type), this resolution is stored in the + QUAL_RESOLUTION of the qual element being examined. We need to + save the current_class since the use of SUPER might change the + its value. */ + saved_current_class = current_class; + qual = EXPR_WFL_QUALIFICATION (id); + do { + + /* Simple qualified expression feature a qual_wfl that is a + WFL. Expression derived from a primary feature more complicated + things like a CALL_EXPR. Expression from primary need to be + worked out to extract the part on which the qualification will + take place. */ + qual_wfl = QUAL_WFL (qual); + switch (TREE_CODE (qual_wfl)) + { + case CALL_EXPR: + qual_wfl = TREE_OPERAND (qual_wfl, 0); + if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION) + { + qual = EXPR_WFL_QUALIFICATION (qual_wfl); + qual_wfl = QUAL_WFL (qual); + } + break; + case NEW_CLASS_EXPR: + case CONVERT_EXPR: + 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; + again = 0; + /* If we have a THIS (from a primary), we set the context accordingly */ + if (name == this_identifier_node) + { + qual = TREE_CHAIN (qual); + qual_wfl = QUAL_WFL (qual); + name = EXPR_WFL_NODE (qual_wfl); + this_found = 1; + } + /* If we have a SUPER, we set the context accordingly */ + if (name == super_identifier_node) + { + current_class = CLASSTYPE_SUPER (ptr_type); + /* Check that there is such a thing as a super class. If not, + return. The error will be caught later on, during the + resolution */ + if (!current_class) + { + current_class = saved_current_class; + return; + } + qual = TREE_CHAIN (qual); + /* Do one more interation to set things up */ + super_found = 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; + QUAL_RESOLUTION (qual) = decl; + } + + /* 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))) + { + RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1; + QUAL_RESOLUTION (qual) = decl; + } + + /* We reclassify NAME as a type name if: + - NAME is a class/interface declared within the compilation + unit containing NAME, + - NAME is imported via a single-type-import declaration, + - NAME is declared in an another compilation unit of the package + of the compilation unit containing NAME, + - NAME is declared by exactly on type-import-on-demand declaration + of the compilation unit containing NAME. */ + else if ((decl = resolve_and_layout (name, NULL_TREE))) + { + RESOLVE_TYPE_NAME_P (qual_wfl) = 1; + QUAL_RESOLUTION (qual) = decl; + } + + /* Method call are expression name */ + else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR) + RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1; + + /* Check here that NAME isn't declared by more than one + type-import-on-demand declaration of the compilation unit + containing NAME. FIXME */ + + /* Otherwise, NAME is reclassified as a package name */ + else + RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1; + + /* Propagate the qualification accross other components of the + qualified name */ + for (qual = TREE_CHAIN (qual); qual; + qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual)) + { + if (RESOLVE_PACKAGE_NAME_P (qual_wfl)) + RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1; + else + RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1; + } + + /* Store the global qualification for the ambiguous part of ID back + into ID fields */ + if (RESOLVE_EXPRESSION_NAME_P (qual_wfl)) + RESOLVE_EXPRESSION_NAME_P (id) = 1; + else if (RESOLVE_TYPE_NAME_P (qual_wfl)) + RESOLVE_TYPE_NAME_P (id) = 1; + else if (RESOLVE_PACKAGE_NAME_P (qual_wfl)) + RESOLVE_PACKAGE_NAME_P (id) = 1; + + /* Restore the current class */ + current_class = saved_current_class; +} + +static int +breakdown_qualified (left, right, source) + tree *left, *right, source; +{ + char *p = IDENTIFIER_POINTER (source), *base; + int l = IDENTIFIER_LENGTH (source); + + /* Breakdown NAME into REMAINDER . IDENTIFIER */ + base = p; + p += (l-1); + while (*p != '.' && p != base) + p--; + + /* We didn't find a '.'. Return an error */ + if (p == base) + return 1; + + *p = '\0'; + if (right) + *right = get_identifier (p+1); + *left = get_identifier (IDENTIFIER_POINTER (source)); + *p = '.'; + + return 0; +} + +static int +not_initialized_as_it_should_p (decl) + tree decl; +{ + if (DECL_P (decl)) + { + if (TREE_CODE (decl) == FIELD_DECL + && METHOD_STATIC (current_function_decl)) + return 0; + return DECL_P (decl) && !INITIALIZED_P (decl); + } + return 0; +} + +/* Patch tree nodes in a function body. When a BLOCK is found, push + local variable decls if present. */ + +static tree +java_complete_tree (node) + tree node; +{ + tree nn, cn, wfl_op1, wfl_op2; + int flag; + + /* CONVERT_EXPR always has its type set, even though it needs to be + worked out. */ + if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR) + return node; + + /* The switch block implements cases processing container nodes + first. Contained nodes are always written back. Leaves come + next and return a value. */ + switch (TREE_CODE (node)) + { + case BLOCK: + + /* 1- Block section. + Set the local values on decl names so we can identify them + faster when they're referenced. At that stage, identifiers + are legal so we don't check for declaration errors. */ + for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn)) + { + DECL_CONTEXT (cn) = current_function_decl; + IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn; + INITIALIZED_P (cn) = 0; + } + if (BLOCK_EXPR_BODY (node)) + { + BLOCK_EXPR_BODY (node) = java_complete_tree (BLOCK_EXPR_BODY (node)); + if (BLOCK_EXPR_BODY (node) == error_mark_node) + return error_mark_node; + } + /* Turn local bindings to null */ + for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn)) + IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE; + + TREE_TYPE (node) = void_type_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); + return patch_throw_statement (node, wfl_op1); + + case SYNCHRONIZED_EXPR: + wfl_op1 = TREE_OPERAND (node, 0); + COMPLETE_CHECK_OP_0 (node); + COMPLETE_CHECK_OP_1 (node); + return patch_synchronized_statement (node, wfl_op1); + + case TRY_EXPR: + return patch_try_statement (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 (); + return node; + + case EXIT_BLOCK_EXPR: + /* We don't complete operand 1, because it's the return value of + the EXIT_BLOCK_EXPR which doesn't exist it Java */ + return patch_bc_statement (node); + + 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 */ + 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 (); + POP_LOOP (); + return nn; + + case EXIT_EXPR: + TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0)); + return patch_exit_expr (node); + + case COND_EXPR: + /* Condition */ + TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0)); + if (TREE_OPERAND (node, 0) == error_mark_node) + return error_mark_node; + /* then-else branches */ + TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1)); + if (TREE_OPERAND (node, 1) == error_mark_node) + return error_mark_node; + TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2)); + if (TREE_OPERAND (node, 2) == error_mark_node) + return error_mark_node; + return patch_if_else_statement (node); + break; + + /* 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; + TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1)); + break; + + case RETURN_EXPR: + 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); + 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) + { + /* Its important for the evaluation of assignment that + this mark on the TREE_TYPE is propagated. */ + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } + else + TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node)); + } + break; + + case NEW_ARRAY_EXPR: + /* Patch all the dimensions */ + flag = 0; + for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn)) + { + int location = EXPR_WFL_LINECOL (TREE_VALUE (cn)); + tree dim = java_complete_tree (TREE_VALUE (cn)); + if (dim == error_mark_node) + { + flag = 1; + continue; + } + else + { + TREE_VALUE (cn) = dim; + /* Setup the location of the current dimension, for + later error report. */ + TREE_PURPOSE (cn) = + build_expr_wfl (NULL_TREE, input_filename, 0, 0); + EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location; + } + } + /* They complete the array creation expression, if no errors + were found. */ + return (flag ? error_mark_node : patch_newarray (node)); + + case NEW_CLASS_EXPR: + case CALL_EXPR: + /* Complete function's argument(s) first */ + if (complete_function_arguments (node)) + return error_mark_node; + else + { + tree decl; + node = patch_method_invocation_stmt (node, NULL_TREE, + NULL_TREE, 0, &decl); + if (node != error_mark_node) + check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl); + return 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); + 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)); + + /* 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, we still mark the lhs as initialized */ + if (DECL_P (TREE_OPERAND (node, 0))) + INITIALIZED_P (TREE_OPERAND (node, 0)) = 1; + + return error_mark_node; + } + TREE_OPERAND (node, 1) = nn; + + /* 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; + return patch_assignment (node, wfl_op1, wfl_op2); + + case MULT_EXPR: + case PLUS_EXPR: + case MINUS_EXPR: + case LSHIFT_EXPR: + case RSHIFT_EXPR: + case URSHIFT_EXPR: + case BIT_AND_EXPR: + case BIT_XOR_EXPR: + case BIT_IOR_EXPR: + case TRUNC_MOD_EXPR: + case RDIV_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: + /* Operands 0 and 1 are WFL in certain cases only. patch_binop + knows how to handle those cases. */ + wfl_op1 = TREE_OPERAND (node, 0); + wfl_op2 = TREE_OPERAND (node, 1); + + /* Don't complete string nodes if dealing with the PLUS operand. */ + if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1)) + { + TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1); + if (TREE_OPERAND (node, 0) == error_mark_node) + return error_mark_node; + } + if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2)) + { + 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 UNARY_PLUS_EXPR: + case NEGATE_EXPR: + case TRUTH_NOT_EXPR: + case BIT_NOT_EXPR: + case PREDECREMENT_EXPR: + case PREINCREMENT_EXPR: + case POSTDECREMENT_EXPR: + case POSTINCREMENT_EXPR: + case CONVERT_EXPR: + /* There are cases were wfl_op1 is a WFL. patch_unaryop knows + how to handle those cases. */ + wfl_op1 = TREE_OPERAND (node, 0); + 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); + + case ARRAY_REF: + /* There are cases were wfl_op1 is a WFL. patch_array_ref knows + how to handle those cases. */ + wfl_op1 = TREE_OPERAND (node, 0); + 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; + TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1)); + return patch_array_ref (node, wfl_op1, wfl_op2); + + case THIS_EXPR: + /* Can't use THIS in a static environment */ + if (!current_this) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + parse_error_context (wfl_operator, "Keyword `this' used outside " + "allowed context"); + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } + return current_this; + + default: + /* 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)]); + } + return node; +} + +/* Complete function call's argument. Return a non zero value is an + error was found. */ + +static int +complete_function_arguments (node) + tree node; +{ + int flag = 0; + tree cn; + + for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn)) + { + tree wfl = TREE_VALUE (cn), parm, temp; + parm = java_complete_tree (wfl); + if (parm == error_mark_node) + { + flag = 1; + continue; + } + /* 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; + TREE_VALUE (cn) = parm; + + if (not_initialized_as_it_should_p (parm)) + { + ERROR_VARIABLE_NOT_INITIALIZED (wfl, EXPR_WFL_NODE (wfl)); + INITIALIZED_P (parm) = 1; + } + } + return flag; +} + +/* Sometimes (for loops and variable initialized during their + declaration), we want to wrap a statement around a WFL and turn it + debugable. */ + +static tree +build_debugable_stmt (location, stmt) + int location; + tree stmt; +{ + if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION) + { + stmt = build_expr_wfl (stmt, input_filename, 0, 0); + EXPR_WFL_LINECOL (stmt) = location; + } + JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt); + return stmt; +} + +static tree +build_expr_block (body, decls) + tree body, decls; +{ + tree node = make_node (BLOCK); + BLOCK_EXPR_DECLS (node) = decls; + 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 it approriately to current + function block chain */ + +static tree +enter_block () +{ + 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)) + { + BLOCK_SUPERCONTEXT (b) = fndecl; + DECL_FUNCTION_BODY (fndecl) = b; + } + else + { + BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl); + DECL_FUNCTION_BODY (fndecl) = b; + } + return b; +} + +/* Exit a block by changing the current function body + (DECL_FUNCTION_BODY) to the current block super context, only if + the block being exited isn't the method's top level one. */ + +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); + + return b; +} + +/* Lookup for NAME in the nested function's blocks, all the way up to + the current toplevel one. It complies with Java's local variable + scoping rules. */ + +static tree +lookup_name_in_blocks (name) + tree name; +{ + tree b = DECL_FUNCTION_BODY (current_function_decl); + + while (b != current_function_decl) + { + tree current; + + /* Paranoid sanity check. To be removed */ + if (TREE_CODE (b) != BLOCK) + fatal ("non block expr function body - lookup_name_in_blocks"); + + for (current = BLOCK_EXPR_DECLS (b); current; + current = TREE_CHAIN (current)) + if (DECL_NAME (current) == name) + return current; + b = BLOCK_SUPERCONTEXT (b); + } + return NULL_TREE; +} + +static void +maybe_absorb_scoping_blocks () +{ + while (BLOCK_EXPR_ORIGIN (DECL_FUNCTION_BODY (current_function_decl))) + { + tree b = exit_block (); + java_method_add_stmt (current_function_decl, b); + SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno)); + } +} + + +/* This section of the source is reserved to build_* functions that + are building incomplete tree nodes and the patch_* functions that + are completing them. */ + +/* Build an incomplete CALL_EXPR node. */ + +static tree +build_method_invocation (name, args) + tree name; + tree args; +{ + tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE); + TREE_SIDE_EFFECTS (call) = 1; + 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; +} + +/* Build an incomplete assignment expression. */ + +static tree +build_assignment (op, op_location, lhs, rhs) + int op, op_location; + tree lhs, rhs; +{ + tree assignment; + /* Build the corresponding binop if we deal with a Compound + Assignment operator. Mark the binop sub-tree as part of a + Compound Assignment expression */ + if (op != ASSIGN_TK) + { + rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs); + COMPOUND_ASSIGN_P (rhs) = 1; + } + assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs); + TREE_SIDE_EFFECTS (assignment) = 1; + EXPR_WFL_LINECOL (assignment) = op_location; + return assignment; +} + +/* Print an INTEGER_CST node in a static buffer, and return the buffer. */ + +static char * +print_int_node (node) + tree node; +{ + static char buffer [80]; + if (TREE_CONSTANT_OVERFLOW (node)) + sprintf (buffer, "<overflow>"); + + if (TREE_INT_CST_HIGH (node) == 0) + sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED, + TREE_INT_CST_LOW (node)); + else if (TREE_INT_CST_HIGH (node) == -1 + && TREE_INT_CST_LOW (node) != 0) + { + buffer [0] = '-'; + sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED, + -TREE_INT_CST_LOW (node)); + } + else + sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX, + TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node)); + + return buffer; +} + +/* 15.25 Assignment operators. */ + +static tree +patch_assignment (node, wfl_op1, wfl_op2) + tree node; + tree wfl_op1; + tree wfl_op2; +{ + tree rhs = TREE_OPERAND (node, 1); + tree lvalue = TREE_OPERAND (node, 0); + tree lhs_type, rhs_type, new_rhs = NULL_TREE; + 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; + } + + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + + /* Lhs can be a named variable */ + if (DECL_P (lvalue)) + { + INITIALIZED_P (lvalue) = 1; + lhs_type = TREE_TYPE (lvalue); + } + /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME + + comment on reason why */ + else if (TREE_CODE (wfl_op1) == ARRAY_REF) + { + lhs_type = TREE_TYPE (lvalue); + lvalue_from_array = 1; + } + /* Or a field access */ + else if (TREE_CODE (lvalue) == COMPONENT_REF) + lhs_type = TREE_TYPE (lvalue); + /* Or a function return slot */ + else if (TREE_CODE (lvalue) == RESULT_DECL) + lhs_type = TREE_TYPE (lvalue); + /* Otherwise, this is an error */ + 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 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 */ + else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1))) + new_rhs = convert (lhs_type, rhs); + + /* Explicit cast required. This is an error */ + if (!new_rhs) + { + 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 */ + + /* If the assignment is part of a declaration, we use the WFL of + the declared variable to point out the error and call it a + declaration problem. If the assignment is a genuine = + operator, we call is a operator `=' problem, otherwise we + call it an assignment problem. In both of these last cases, + we use the WFL of the operator to indicate the error. */ + + if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)) + { + wfl = wfl_op1; + strcpy (operation, "declaration"); + } + else + { + wfl = wfl_operator; + if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1))) + strcpy (operation, "assignment"); + else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL) + strcpy (operation, "`return'"); + else + strcpy (operation, "`='"); + } + + parse_error_context + (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); + free (t1); free (t2); + 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; + } + + if (error_found) + return error_mark_node; + + /* If we built a compound expression as the result of a reference + 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 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); + + /* 5.1.1 Try Identity Conversion, + 5.1.2 Try Widening Primitive Conversion */ + 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 +valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type) + tree lhs_type, rhs_type; +{ + int all_primitive = + JPRIMITIVE_TYPE_P (lhs_type) && JPRIMITIVE_TYPE_P (rhs_type); + + if (!all_primitive) + return 0; + + if (lhs_type == rhs_type) + return 1; + + /* 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; + + if (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)))) + return 1; + else if (JFLOAT_TYPE_P (rhs_type) + && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type))) + return 1; + + return 0; +} + +/* Check that something of SOURCE type can be assigned or cast to + something of DEST type at runtime. Return 1 if the operation is + valid, 0 otherwise. If CAST is set to 1, we're treating the case + were SOURCE is cast into DEST, which borrows a lot of the + assignment check. */ + +static int +valid_ref_assignconv_cast_p (source, dest, cast) + tree source; + tree dest; + int cast; +{ + if (TREE_CODE (source) == POINTER_TYPE) + source = TREE_TYPE (source); + if (TREE_CODE (dest) == POINTER_TYPE) + dest = TREE_TYPE (dest); + /* Case where SOURCE is a class type */ + if (TYPE_CLASS_P (source)) + { + if (TYPE_CLASS_P (dest)) + return source == dest || inherits_from_p (source, dest) + || (cast && inherits_from_p (dest, source)); + if (TYPE_INTERFACE_P (dest)) + { + /* If doing a cast and SOURCE is final, the operation is + always correct a compile time (because even if SOURCE + does not implement DEST, a subclass of SOURCE might). */ + if (cast && !CLASS_FINAL (TYPE_NAME (source))) + return 1; + /* Otherwise, SOURCE must implement DEST */ + return interface_of_p (dest, source); + } + /* DEST is an array, cast permited if SOURCE is of Object type */ + return (cast && source == object_type_node ? 1 : 0); + } + if (TYPE_INTERFACE_P (source)) + { + if (TYPE_CLASS_P (dest)) + { + /* If not casting, DEST must be the Object type */ + if (!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 (dest))) + return 1; + else + return interface_of_p (source, dest); + } + if (TYPE_INTERFACE_P (dest)) + { + /* If doing a cast, then if SOURCE and DEST contain method + with the same signature but different return type, then + this is a (compile time) error */ + if (cast) + { + tree method_source, method_dest; + tree source_type; + tree source_sig; + tree source_name; + for (method_source = TYPE_METHODS (source); method_source; + method_source = TREE_CHAIN (method_source)) + { + source_sig = + build_java_argument_signature (TREE_TYPE (method_source)); + source_type = TREE_TYPE (TREE_TYPE (method_source)); + source_name = DECL_NAME (method_source); + for (method_dest = TYPE_METHODS (dest); + method_dest; method_dest = TREE_CHAIN (method_dest)) + if (source_sig == + build_java_argument_signature (TREE_TYPE (method_dest)) + && source_name == DECL_NAME (method_dest) + && source_type != TREE_TYPE (TREE_TYPE (method_dest))) + return 0; + } + return 1; + } + else + return source == dest || interface_of_p (dest, source); + } + else /* Array */ + return 0; + } + if (TYPE_ARRAY_P (source)) + { + if (TYPE_CLASS_P (dest)) + return dest == object_type_node; + if (TYPE_INTERFACE_P (dest)) + return 0; /* Install test on Clonable. FIXME */ + 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, + dest_element_type, cast); + } + return 0; + } + 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 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) + && JREFERENCE_TYPE_P (dest) + && valid_ref_assignconv_cast_p (source, dest, 0))); +} + +/* Build an incomplete binop expression. */ + +static tree +build_binop (op, op_location, op1, op2) + enum tree_code op; + int op_location; + tree op1, op2; +{ + tree binop; + + 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. */ + EXPR_WFL_LINECOL (binop) = op_location; + return binop; +} + +/* Build the string of the operator retained by NODE. If NODE is part + of a compound expression, add an '=' at the end of the string. This + function is called when an error needs to be reported on an + operator. The string is returned as a pointer to a static character + buffer. */ + +static char * +operator_string (node) + tree node; +{ +#define BUILD_OPERATOR_STRING(S) \ + { \ + sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \ + return buffer; \ + } + + static char buffer [10]; + switch (TREE_CODE (node)) + { + case MULT_EXPR: BUILD_OPERATOR_STRING ("*"); + case RDIV_EXPR: BUILD_OPERATOR_STRING ("/"); + case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%"); + case PLUS_EXPR: BUILD_OPERATOR_STRING ("+"); + case MINUS_EXPR: BUILD_OPERATOR_STRING ("-"); + case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<"); + case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>"); + case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>"); + case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&"); + case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^"); + case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|"); + case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&"); + case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||"); + case EQ_EXPR: BUILD_OPERATOR_STRING ("=="); + case NE_EXPR: BUILD_OPERATOR_STRING ("!="); + case GT_EXPR: BUILD_OPERATOR_STRING (">"); + case GE_EXPR: BUILD_OPERATOR_STRING (">="); + case LT_EXPR: BUILD_OPERATOR_STRING ("<"); + case LE_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 ("~"); + case PREINCREMENT_EXPR: /* Fall through */ + case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++"); + case PREDECREMENT_EXPR: /* Fall through */ + case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--"); + default: + fatal ("unregistered operator %s - operator_string", + tree_code_name [TREE_CODE (node)]); + } + return NULL; +#undef BUILD_OPERATOR_STRING +} + +/* Binary operators (15.16 up to 15.18). We return error_mark_node on + errors but we modify NODE so that it contains the type computed + according to the expression, when it's fixed. Otherwise, we write + error_mark_node as the type. It allows us to further the analysis + of remaining nodes and detects more errors in certain cases. */ + +static tree +patch_binop (node, wfl_op1, wfl_op2) + tree node; + tree wfl_op1; + tree wfl_op2; +{ + tree op1 = TREE_OPERAND (node, 0); + tree op2 = TREE_OPERAND (node, 1); + tree op1_type = TREE_TYPE (op1); + 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 */ + case MULT_EXPR: /* 15.16.1 Multiplication Operator * */ + case RDIV_EXPR: /* 15.16.2 Division Operator / */ + case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */ + if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type)) + { + if (!JPRIMITIVE_TYPE_P (op1_type)) + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type); + if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type)) + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type); + TREE_TYPE (node) = error_mark_node; + error_found = 1; + break; + } + prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &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. */ + if (code == TRUNC_MOD_EXPR) + return build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2); + break; + + /* 15.17 Additive Operators */ + case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */ + + /* 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)) + { + if (!JPRIMITIVE_TYPE_P (op1_type)) + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type); + if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type)) + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type); + TREE_TYPE (node) = error_mark_node; + error_found = 1; + break; + } + prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2); + break; + + /* 15.18 Shift Operators */ + case LSHIFT_EXPR: + case RSHIFT_EXPR: + case URSHIFT_EXPR: + if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type)) + { + if (!JINTEGRAL_TYPE_P (op1_type)) + ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type); + else + parse_error_context + (wfl_operator, (JPRIMITIVE_TYPE_P (op2_type) ? + "Incompatible type for `%s'. Explicit cast needed to convert " + "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, 0)); + TREE_TYPE (node) = error_mark_node; + error_found = 1; + break; + } + + /* 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); + + /* The type of the shift expression is the type of the promoted + type of the left-hand operand */ + prom_type = TREE_TYPE (op1); + + /* Shift int only up to 0x1f and long up to 0x3f */ + if (prom_type == int_type_node) + op2 = fold (build (BIT_AND_EXPR, int_type_node, op2, + build_int_2 (0x1f, 0))); + else + op2 = fold (build (BIT_AND_EXPR, int_type_node, op2, + build_int_2 (0x3f, 0))); + + /* The >>> operator is a >> operating on unsigned quantities */ + if (code == URSHIFT_EXPR) + { + op1 = convert (unsigned_type (prom_type), op1); + TREE_SET_CODE (node, RSHIFT_EXPR); + } + break; + + + /* 15.21 Bitwise and Logical Operators */ + case BIT_AND_EXPR: + case BIT_XOR_EXPR: + case BIT_IOR_EXPR: + if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type)) + /* Binary numeric promotion is performed on both operand and the + expression retain that type */ + prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2); + + else if (TREE_CODE (op1_type) == BOOLEAN_TYPE + && TREE_CODE (op1_type) == BOOLEAN_TYPE) + /* The type of the bitwise operator expression is BOOLEAN */ + prom_type = boolean_type_node; + else + { + if (!JINTEGRAL_TYPE_P (op1_type)) + ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type); + if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type)) + ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type); + TREE_TYPE (node) = error_mark_node; + error_found = 1; + /* Insert a break here if adding thing before the switch's + break for this case */ + } + break; + + /* 15.22 Conditional-And Operator */ + case TRUTH_ANDIF_EXPR: + /* 15.23 Conditional-Or Operator */ + case TRUTH_ORIF_EXPR: + /* Operands must be of BOOLEAN type */ + if (TREE_CODE (op1_type) != BOOLEAN_TYPE || + TREE_CODE (op2_type) != BOOLEAN_TYPE) + { + if (TREE_CODE (op1_type) != BOOLEAN_TYPE) + ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type); + if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type)) + ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type); + TREE_TYPE (node) = boolean_type_node; + error_found = 1; + break; + } + /* The type of the conditional operators is BOOLEAN */ + prom_type = boolean_type_node; + break; + + /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */ + case LT_EXPR: + case GT_EXPR: + case LE_EXPR: + case GE_EXPR: + /* The type of each of the operands must be a primitive numeric + type */ + if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type)) + { + if (!JNUMERIC_TYPE_P (op1_type)) + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type); + if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type)) + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type); + TREE_TYPE (node) = boolean_type_node; + error_found = 1; + break; + } + /* Binary numeric promotion is performed on the operands */ + binary_numeric_promotion (op1_type, op2_type, &op1, &op2); + /* The type of the relation expression is always BOOLEAN */ + prom_type = boolean_type_node; + break; + + /* 15.20 Equality Operator */ + case EQ_EXPR: + 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)) + binary_numeric_promotion (op1_type, op2_type, &op1, &op2); + + /* 15.20.2 Boolean Equality Operators == and != */ + else if (TREE_CODE (op1_type) == BOOLEAN_TYPE && + TREE_CODE (op2_type) == BOOLEAN_TYPE) + ; /* 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)))) + ; /* Nothing to do here */ + + /* Else we have an error figure what can't be converted into + what and report the error */ + else + { + char *t1; + 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, 0)); + free (t1); + TREE_TYPE (node) = boolean_type_node; + error_found = 1; + break; + } + prom_type = boolean_type_node; + 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); +} + +/* 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; + + /* Try to do some static optimization */ + if ((result = string_constant_concatenation (op1, op2))) + return result; + + /* If operands are string constant, turn then into object references */ + + if (TREE_CODE (op1) == STRING_CST) + op1 = patch_string_cst (op1); + if (TREE_CODE (op2) == STRING_CST) + op2 = patch_string_cst (op2); + + /* 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) Op2 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); + } + } + + /* No longer the last node holding a crafted StringBuffer */ + IS_CRAFTED_STRING_BUFFER_P (op1) = 0; + /* Create a node for `{new...,xxx}.append (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; + + return op1; +} + +/* 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 (TREE_CODE (node) == STRING_CST) + return patch_string_cst (node); + else if (IS_CRAFTED_STRING_BUFFER_P (node)) + { + tree invoke = build_method_invocation (wfl_to_string, NULL_TREE); + return java_complete_tree (make_qualified_primary (node, invoke, 0)); + } + return NULL_TREE; +} + +/* Build the internal representation of a string constant. */ + +static tree +patch_string_cst (node) + tree node; +{ + int location; + 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) + int op_token, op_location; + tree op1; +{ + enum tree_code op; + tree unaryop; + switch (op_token) + { + 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; + default: fatal ("Unknown token `%d' for unary operator - build_unaryop", + op_token); + } + + unaryop = build1 (op, NULL_TREE, op1); + 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. */ + EXPR_WFL_LINECOL (unaryop) = op_location; + return unaryop; +} + +/* Special case for the ++/-- operators, since they require an extra + argument to build, which is set to NULL and patched + later. IS_POST_P is 1 if the operator, 0 otherwise. */ + +static tree +build_incdec (op_token, op_location, op1, is_post_p) + int op_token, op_location; + tree op1; + int is_post_p; +{ + static enum tree_code lookup [2][2] = + { + { PREDECREMENT_EXPR, PREINCREMENT_EXPR, }, + { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, }, + }; + tree node = build (lookup [is_post_p][(op_token - DECR_TK)], + NULL_TREE, op1, NULL_TREE); + TREE_SIDE_EFFECTS (node) = 1; + /* Store the location of the operator, for better error report. The + string of the operator will be rebuild based on the OP value. */ + EXPR_WFL_LINECOL (node) = op_location; + return node; +} + +/* Build an incomplete cast operator, based on the use of the + CONVERT_EXPR. Note that TREE_TYPE of the constructed node is + set. java_complete_tree is trained to walk a CONVERT_EXPR even + though its type is already set. */ + +static tree +build_cast (location, type, exp) + int location; + tree type, exp; +{ + tree node = build1 (CONVERT_EXPR, type, exp); + EXPR_WFL_LINECOL (node) = location; + return node; +} + +/* 15.14 Unary operators. We return error_mark_node in case of error, + but preserve the type of NODE if the type is fixed. */ + +static tree +patch_unaryop (node, wfl_op) + tree node; + tree wfl_op; +{ + tree op = TREE_OPERAND (node, 0); + tree op_type = TREE_TYPE (op); + tree prom_type, value; + int code = TREE_CODE (node); + int error_found = 0; + + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + + switch (code) + { + /* 15.13.2 Postfix Increment Operator ++ */ + case POSTINCREMENT_EXPR: + /* 15.13.3 Postfix Increment Operator -- */ + case POSTDECREMENT_EXPR: + /* 15.14.1 Prefix Increment Operator ++ */ + case PREINCREMENT_EXPR: + /* 15.14.2 Prefix Decrement Operator -- */ + case PREDECREMENT_EXPR: + if (!DECL_P (op) && !(TREE_CODE (op) == INDIRECT_REF + && JPRIMITIVE_TYPE_P (TREE_TYPE (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)) + { + parse_error_context + (wfl_op, "Can't assign a value to the final variable `%s'", + IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op))); + TREE_TYPE (node) = error_mark_node; + 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. */ + else if (!JNUMERIC_TYPE_P (op_type)) + { + parse_error_context + (wfl_op, "Invalid argument type `%s' to `%s'", + 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 + both operands */ + value = integer_one_node; + prom_type = binary_numeric_promotion (op_type, TREE_TYPE (value), + &op, &value); + /* And write the promoted increment back */ + TREE_OPERAND (node, 1) = value; + } + break; + + /* 15.14.3 Unary Plus Operator + */ + case UNARY_PLUS_EXPR: + /* 15.14.4 Unary Minus Operator - */ + case NEGATE_EXPR: + if (!JNUMERIC_TYPE_P (op_type)) + { + ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type); + TREE_TYPE (node) = error_mark_node; + error_found = 1; + } + /* Unary numeric promotion is performed on operand */ + else + { + prom_type = promote_type (op_type); + op = convert (prom_type, op); + if (code == UNARY_PLUS_EXPR) + node = op; + } + break; + + /* 15.14.5 Bitwise Complement Operator ~ */ + case BIT_NOT_EXPR: + if (!JINTEGRAL_TYPE_P (op_type)) + { + ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type); + TREE_TYPE (node) = error_mark_node; + error_found = 1; + } + else + { + prom_type = promote_type (op_type); + op = convert (prom_type, op); + } + break; + + /* 15.14.6 Logical Complement Operator ! */ + case TRUTH_NOT_EXPR: + if (TREE_CODE (op_type) != BOOLEAN_TYPE) + { + ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type); + TREE_TYPE (node) = boolean_type_node; + error_found = 1; + } + else + prom_type = boolean_type_node; + break; + + /* 15.15 Cast Expression */ + case CONVERT_EXPR: + value = patch_cast (node, wfl_operator); + if (value == error_mark_node) + { + TREE_TYPE (node) = error_mark_node; + error_found = 1; + } + else + node = 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 UNARY_PLUS_EXPR, we replaced NODE by a new one */ + else if (code != UNARY_PLUS_EXPR && code != CONVERT_EXPR) + { + TREE_OPERAND (node, 0) = op; + TREE_TYPE (node) = prom_type; + } + return fold (node); +} + +/* Generic type resolution that sometimes takes place during node + patching. Returned the resolved type or generate an error + message. Return the resolved type or NULL_TREE. */ + +static tree +resolve_type_during_patch (type) + tree type; +{ + if (unresolved_type_p (type, NULL)) + { + tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE); + if (!type_decl) + { + parse_error_context (type, + "Class `%s' not found in type declaration", + IDENTIFIER_POINTER (EXPR_WFL_NODE (type))); + return NULL_TREE; + } + else + return TREE_TYPE (type_decl); + } + return type; +} +/* 5.5 Casting Conversion. error_mark_node is returned if an error is + found. Otherwise NODE or something meant to replace it is returned. */ + +static tree +patch_cast (node, wfl_operator) + tree node; + tree wfl_operator; +{ + tree op = TREE_OPERAND (node, 0); + tree op_type = TREE_TYPE (op); + tree cast_type = TREE_TYPE (node); + char *t1; + + /* First resolve OP_TYPE if unresolved */ + if (!(cast_type = resolve_type_during_patch (cast_type))) + return error_mark_node; + + /* Check on cast that are proven correct at compile time */ + if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type)) + { + static tree convert_narrow (); + /* Same type */ + if (cast_type == op_type) + return node; + + /* 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); + } + + /* 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) + && valid_ref_assignconv_cast_p (cast_type, op_type, 1)) + { + TREE_TYPE (node) = promote_type (cast_type); + /* Now, the case can be determined correct at compile time if + OP_TYPE can be converted into CAST_TYPE by assignment + conversion (5.2) */ + + if (valid_ref_assignconv_cast_p (op_type, cast_type, 0)) + return node; + + /* The cast requires a run-time check */ + return build (CALL_EXPR, promote_type (cast_type), + build_address_of (soft_checkcast_node), + tree_cons (NULL_TREE, build_class_ref (cast_type), + build_tree_list (NULL_TREE, op)), + NULL_TREE); + } + + /* Any other casts are proven incorrect at compile time */ + 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, 0)); + free (t1); + return error_mark_node; +} + +/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't + a list of indices. */ +static tree +build_array_ref (location, array, index) + int location; + tree array, index; +{ + tree node = build (ARRAY_REF, NULL_TREE, array, index); + EXPR_WFL_LINECOL (node) = location; + return node; +} + +/* 15.12 Array Access Expression */ + +static tree +patch_array_ref (node, wfl_array, wfl_index) + tree node, wfl_array, wfl_index; +{ + 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 (TREE_CODE (array_type) == POINTER_TYPE) + array_type = TREE_TYPE (array_type); + + /* The array reference must be an array */ + if (!TYPE_ARRAY_P (array_type)) + { + parse_error_context + (wfl_operator, "`[]' can only be applied to arrays. It can't be " + "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) + { + 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, 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)); + if (flag_emit_class_files) + { + TREE_OPERAND (node, 0)= array; + TREE_OPERAND (node, 1)= index; + } + else + node = build_java_arrayaccess (array, array_type, index); + TREE_TYPE (node) = array_type; + return node; +} + +/* 15.9 Array Creation Expressions */ + +static tree +build_newarray_node (type, dims, extra_dims) + tree type; + tree dims; + int extra_dims; +{ + tree node = + build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims), + build_int_2 (extra_dims, 0)); + return node; +} + +static tree +patch_newarray (node) + tree node; +{ + tree type = TREE_OPERAND (node, 0); + tree dims = TREE_OPERAND (node, 1); + tree cdim, array_type; + 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. */ + for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ ) + { + int dim_error = 0; + tree dim = TREE_VALUE (cdim); + + /* Dim might have been saved during its evaluation */ + dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim); + + /* The type of each specified dimension must be an integral type. */ + if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim))) + dim_error = 1; + + /* Each expression undergoes an unary numeric promotion (5.6.1) and the + promoted type must be int. */ + else + { + dim = convert (promote_type (TREE_TYPE (dim)), dim); + if (TREE_TYPE (dim) != int_type_node) + dim_error = 1; + } + + /* Report errors on types here */ + if (dim_error) + { + parse_error_context + (TREE_PURPOSE (cdim), + "Incompatible type for dimension in array creation expression. " + "%s convert `%s' to `int'", + (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ? + "Explicit cast needed to" : "Can't"), + lang_printable_name (TREE_TYPE (dim), 0)); + 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; + error_found = 1; + } + + TREE_PURPOSE (cdim) = NULL_TREE; + } + + /* Resolve array base type if unresolved */ + if (!(type = resolve_type_during_patch (type))) + error_found = 1; + + if (error_found) + { + /* We don't want further evaluation of this bogus array creation + operation */ + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } + + /* 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 (JPRIMITIVE_TYPE_P (type)) + { + 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)); + } + else + return build_anewarray (type, TREE_VALUE (dims)); + } + + /* 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)); + + /* 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); +} + +static tree +build_this (location) + int location; +{ + tree node = build_wfl_node (this_identifier_node, input_filename, 0, 0); + TREE_SET_CODE (node, THIS_EXPR); + EXPR_WFL_LINECOL (node) = location; + return node; +} + +/* 14.15 The return statement. It builds a modify expression that + assigns the returned value to the RESULT_DECL that hold the value + to be returned. */ + +static tree +build_return (location, op) + int location; + tree op; +{ + tree node = build1 (RETURN_EXPR, NULL_TREE, op); + EXPR_WFL_LINECOL (node) = location; + node = build_debugable_stmt (location, node); + return node; +} + +static tree +patch_return (node) + tree 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; + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + + /* It's invalid to have a return value within a function that is + declared with the keyword void or that is a constructor */ + if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth))) + 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))) + error_found = 2; + + if (error_found) + { + 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); + return error_mark_node; + } + + /* If we have a return_exp, build a modify expression and expand it */ + if (return_exp) + { + modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), return_exp); + EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node); + modify = java_complete_tree (modify); + if (modify != error_mark_node) + { + TREE_SIDE_EFFECTS (modify) = 1; + TREE_OPERAND (node, 0) = modify; + } + else + return error_mark_node; + } + TREE_TYPE (node) = void_type_node; + TREE_SIDE_EFFECTS (node) = 1; + return node; +} + +/* 14.8 The if Statement */ + +static tree +build_if_else_statement (location, expression, if_body, else_body) + int location; + 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); + node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body); + EXPR_WFL_LINECOL (node) = location; + node = build_debugable_stmt (location, node); + return node; +} + +static tree +patch_if_else_statement (node) + tree node; +{ + tree expression = TREE_OPERAND (node, 0); + + TREE_TYPE (node) = error_mark_node; + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + + /* The type of expression must be boolean */ + 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), 0)); + return error_mark_node; + } + + TREE_TYPE (node) = void_type_node; + TREE_SIDE_EFFECTS (node) = 1; + return node; +} + +/* 14.6 Labeled Statements */ + +/* Action taken when a lableled statement is parsed. a new + LABELED_BLOCK_EXPR is created. No statement is attached to the + label, yet. */ + +static tree +build_labeled_block (location, label) + int location; + tree label; +{ + tree label_name = merge_qualified_name (label_id, label); + tree label_decl, node; + + /* Issue a warning if we try to reuse a label that was previously + declared */ + if (IDENTIFIER_LOCAL_VALUE (label_name)) + { + 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_decl = create_label_decl (label_name); + node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE); + EXPR_WFL_LINECOL (node) = location; + TREE_SIDE_EFFECTS (node) = 1; + 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 () +{ + return build_labeled_block (0, generate_name ()); +} + +/* A labeled statement LBE is attached a statement. */ + +static tree +complete_labeled_statement (lbe, statement) + tree lbe; /* Labeled block expr */ + tree statement; +{ + /* In anyways, tie the loop to its statement */ + LABELED_BLOCK_BODY (lbe) = statement; + + /* Ok, if statement is a for loop, we have to attach the labeled + statement to the block the for loop belongs to and return the + block instead */ + if (TREE_CODE (statement) == LOOP_EXPR && IS_FOR_LOOP_P (statement)) + { + java_method_add_stmt (current_function_decl, lbe); + return exit_block (); + } + + return lbe; +} + +/* 14.10, 14.11, 14.12 Loop Statements */ + +/* Create an empty LOOP_EXPR and make it the last in the nested loop + list. */ + +static tree +build_new_loop (loop_body) + tree loop_body; +{ + tree loop = build (LOOP_EXPR, NULL_TREE, loop_body); + TREE_SIDE_EFFECTS (loop) = 1; + PUSH_LOOP (loop); + return loop; +} + +/* Create a loop body according to the following structure: + COMPOUND_EXPR + 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 + 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. + + 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) + int location; + tree condition; + int reversed; +{ + 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 (); + first = (reversed ? body : condition); + second = (reversed ? condition : body); + return + build (COMPOUND_EXPR, NULL_TREE, + build (COMPOUND_EXPR, NULL_TREE, first, second), size_zero_node); +} + +/* Install CONDITION (if any) and loop BODY (using REVERSED to tell + their order) on the current loop. Unlink the current loop from the + loop list. */ + +static tree +complete_loop_body (location, condition, body, reversed) + int location; + tree condition, body; + int reversed; +{ + tree to_return = ctxp->current_loop; + tree loop_body = LOOP_EXPR_BODY (to_return); + if (condition) + { + tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed); + /* We wrapped the EXIT_EXPR around a WFL so we can debug it. + The real EXIT_EXPR is one operand further. */ + EXPR_WFL_LINECOL (cnode) = location; + /* This one is for accurate error reports */ + EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location; + TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition; + } + LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body; + POP_LOOP (); + return to_return; +} + +/* Tailored version of complete_loop_body for FOR loops, when FOR + loops feature the condition part */ + +static tree +complete_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); + /* 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; + return loop; +} + +/* If the loop isn't surrounded by a labeled statement, create one and + insert LOOP as it's body. */ + +static tree +patch_loop_statement (loop) + tree loop; +{ + tree loop_label, to_return_as_loop; + + if (LOOP_HAS_LABEL_P (loop)) + { + loop_label = ctxp->current_labeled_block; + to_return_as_loop = loop; + } + else + { + loop_label = generate_labeled_block (); + LABELED_BLOCK_BODY (loop_label) = loop; + PUSH_LABELED_BLOCK (loop_label); + to_return_as_loop = loop_label; + } + TREE_TYPE (to_return_as_loop) = void_type_node; + return to_return_as_loop; +} + +/* 14.13, 14.14: break and continue Statements */ + +/* Build a break or a continue statement. a null NAME indicates an + unlabeled break/continue statement. */ + +static tree +build_bc_statement (location, is_break, name) + int location, is_break; + tree name; +{ + tree break_continue, label_block_expr = NULL_TREE; + + if (name) + { + if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE + (merge_qualified_name (label_id, EXPR_WFL_NODE (name))))) + /* Null means that we don't have a target for this named + break/continue. In this case, we make the target to be the + label name, so that the error can be reported accuratly in + patch_bc_statement. */ + label_block_expr = EXPR_WFL_NODE (name); + } + /* Unlabeled break/continue will be handled during the + break/continue patch operation */ + break_continue + = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE); + + 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; +} + +/* Verification of a break/continue statement. */ + +static tree +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); + + /* Not having a target means that the break/continue statement is + unlabeled. We try to find a decent label for it */ + if (!bc_label) + { + is_unlabeled = 1; + /* There should be a loop/switch to branch to */ + if (ctxp->current_loop) + { + if (TREE_CODE (ctxp->current_loop) == LOOP_EXPR) + { + /* 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 no installed label -- " + "patch_bc_statement"); + bc_label = TREE_CHAIN (ctxp->current_labeled_block); + } + /* For a SWITCH statement, this is the current one */ + else + bc_label = 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) + { + 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)) + { + /* 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 */ + || TREE_CODE (target_stmt) == SWITCH_EXPR)) /* switch FIXME */ + { + parse_error_context (wfl_operator, + "`break' must be in loop or switch"); + return error_mark_node; + } + /* 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 */ + { + parse_error_context (wfl_operator, "`continue' must be in loop"); + return error_mark_node; + } + /* 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; + } + + /* Our break/continue don't return values. */ + TREE_TYPE (node) = void_type_node; + /* Encapsulate the break within a compound statement so that it's + expanded all the times by expand_expr (and not clobered + sometimes, like after a if statement) */ + node = add_stmt_to_compound (NULL_TREE, void_type_node, node); + TREE_SIDE_EFFECTS (node) = 1; + return node; +} + +/* Process the exit expression belonging to a loop. Its type must be + boolean. */ + +static tree +patch_exit_expr (node) + tree node; +{ + tree expression = TREE_OPERAND (node, 0); + TREE_TYPE (node) = error_mark_node; + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node); + + /* The type of expression must be boolean */ + if (TREE_TYPE (expression) != boolean_type_node) + { + parse_error_context + (wfl_operator, + "Incompatible type for loop conditional. Can't convert `%s' to " + "`boolean'", + 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)); + TREE_TYPE (node) = void_type_node; + return node; +} + +/* 14.9 Switch statement */ + +static tree +patch_switch_statement (node) + tree node; +{ + int error_found = 0; + tree se = TREE_OPERAND (node, 0), se_type, sb; + tree default_found = NULL_TREE; + + /* 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; + } + + /* Process the switch body. We should have a list of TREE_LIST. The + PURPOSE of each node should be a list of case values, VALUE + should be the associated block. We try to process all cases and + defaults before returning, possibly finding errors. */ + TREE_OPERAND (node, 1) = nreverse (TREE_OPERAND (node, 1)); + for (sb = TREE_OPERAND (node, 1); sb; sb = TREE_CHAIN (sb)) + { + tree label; + + /* If we don't have a TREE_LIST here, we have a statement inside + the switch that isn't tied to a label. This error is caught + by the parser and we don't have to report it here. */ + + TREE_PURPOSE (sb) = nreverse (TREE_PURPOSE (sb)); + for (label = TREE_PURPOSE (sb); label; label = TREE_CHAIN (label)) + { + tree case_expr; + + /* Verification of the default label */ + if (TREE_CODE (label) == DEFAULT_EXPR) + { + /* Only one default label is allowed per switch + statement */ + if (default_found) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (label); + parse_error_context (wfl_operator, + "Duplicate case label: `default'"); + error_found = 1; + } + else + default_found = label; + continue; + } + /* Verification of case labels */ + else + { + case_expr = java_complete_tree (TREE_OPERAND (label, 0)); + if (case_expr == error_mark_node) + continue; + + /* First, the case expression must be constant */ + case_expr = fold (case_expr); + if (!TREE_CONSTANT (case_expr)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (label); + parse_error_context (label, "Constant expression required"); + error_found = 1; + break; + } + + /* It must be assignable to the type of the switch + expression. */ + if (!try_builtin_assignconv (NULL_TREE, se_type, case_expr)) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (label); + parse_error_context + (wfl_operator, + "Incompatible type for case. Can't convert `%s' to `int'", + lang_printable_name (TREE_TYPE (case_expr), 0)); + error_found = 1; + break; + } + + /* Multiple instance of a case label bearing the same + value is checked during code generation. The case + expression is allright so far. */ + TREE_OPERAND (label, 0) = case_expr; + } + } + + /* First TREE_VALUE should be the block tied to this list of + cases. Check that this block exists and the walk it */ + if (TREE_VALUE (sb)) + { + TREE_VALUE (sb) = java_complete_tree (TREE_VALUE (sb)); + if (TREE_VALUE (sb) == error_mark_node) + error_found = 1; + } + } + + /* Ready to return */ + if (error_found) + { + TREE_TYPE (node) = error_mark_node; + return error_mark_node; + } + TREE_TYPE (node) = void_type_node; + TREE_SIDE_EFFECTS (node) = 1; + return node; +} + +/* Do the expansion of a Java switch. With Gcc, switches are front-end + dependant things, but they rely on gcc routines. This function is + placed here because it uses things defined locally in parse.y. */ + +static tree case_identity (t, v) + tree t __attribute__ ((__unused__)); + tree v; +{ + return v; +} + +void +java_expand_switch (exp) + tree exp; +{ + tree sb; + expand_start_case (0, TREE_OPERAND (exp, 0), int_type_node, "switch"); + + for (sb = TREE_OPERAND (exp, 1); sb; sb = TREE_CHAIN (sb)) + { + /* We have a list of TREE_LIST. PURPOSE is the case value, and + when it exists, VALUE is the associated block */ + + /* The first CASE element should contain the associated block, + if any. All other should be case statements related to the + same block */ + tree label; + for (label = TREE_PURPOSE (sb); label; label = TREE_CHAIN (label)) + { + tree label_decl = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); + if (TREE_CODE (label) == CASE_EXPR) + { + tree duplicate; + if (pushcase (TREE_OPERAND (label, 0), case_identity, + label_decl, &duplicate) == 2) + { + EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (label); + parse_error_context + (wfl_operator, "Duplicate case label: `%s'", + print_int_node (TREE_OPERAND (label, 0))); + } + } + else + pushcase (NULL_TREE, 0, label_decl, NULL); + } + /* Expand the associated block, if any */ + if (TREE_VALUE (sb)) + expand_expr_stmt (TREE_VALUE (sb)); + } + expand_end_case (TREE_OPERAND (exp, 0)); +} + +/* 14.18 The try statement */ + +/* Wrap BLOCK around a LABELED_BLOCK, set DECL to the newly generated + exit labeld and issue a jump to FINALLY_LABEL: + + LABELED_BLOCK + BLOCK + <orignal_statments> + DECL = &LABEL_DECL + GOTO_EXPR + FINALLY_LABEL + LABEL_DECL */ + +static tree +build_jump_to_finally (block, decl, finally_label, type) + tree block, decl, finally_label, type; +{ + tree stmt; + tree new_block = build (LABELED_BLOCK_EXPR, type, + create_label_decl (generate_name ()), block); + + stmt = build (MODIFY_EXPR, void_type_node, decl, + build_address_of (LABELED_BLOCK_LABEL (new_block))); + TREE_SIDE_EFFECTS (stmt) = 1; + add_stmt_to_block (block, type, stmt); + stmt = build (GOTO_EXPR, void_type_node, finally_label); + TREE_SIDE_EFFECTS (stmt) = 1; + add_stmt_to_block (block, type, stmt); + return new_block; +} + +static tree +build_try_statement (location, try_block, catches, finally) + int location; + tree try_block, catches, finally; +{ + tree node, rff; + + if (finally) + { + /* This block defines a scope for the entire try[-catch]-finally + sequence. It hold a local variable used to return from the + finally using a computed goto. We call it + return_from_finally (RFF). */ + rff = build_decl_no_layout (VAR_DECL, generate_name (), + return_address_type_node); + + /* Modification of the try block. */ + try_block = build_jump_to_finally (try_block, rff, + FINALLY_EXPR_LABEL (finally), + NULL_TREE); + + /* To the finally block: add the computed goto */ + add_stmt_to_block (FINALLY_EXPR_BLOCK (finally), NULL_TREE, + build (GOTO_EXPR, void_type_node, rff)); + + /* Modification of each catch blocks, if any */ + if (catches) + { + tree catch, catch_decl, catch_block, stmt; + + for (catch = catches; catch; catch = TREE_CHAIN (catch)) + TREE_OPERAND (catch, 0) = + build_jump_to_finally (TREE_OPERAND (catch, 0), rff, + FINALLY_EXPR_LABEL (finally), + NULL_TREE); + + /* Plus, at the end of the list, we add the catch clause that + will catch an uncaught exception, call finally and rethrow it: + BLOCK + void *exception_parameter; (catch_decl) + LABELED_BLOCK + BLOCK + exception_parameter = _Jv_exception_info (); + RFF = &LABEL_DECL; + goto finally; + LABEL_DECL; + CALL_EXPR + Jv_ReThrow + exception_parameter */ + catch_decl = build_decl_no_layout (VAR_DECL, generate_name (), + ptr_type_node); + BUILD_ASSIGN_EXCEPTION_INFO (stmt, catch_decl); + catch_block = build_expr_block (stmt, NULL_TREE); + catch_block = build_jump_to_finally (catch_block, rff, + FINALLY_EXPR_LABEL (finally), + void_type_node); + BUILD_THROW (stmt, catch_decl); + catch_block = build_expr_block (catch_block, catch_decl); + add_stmt_to_block (catch_block, void_type_node, stmt); + + /* Link the new handler to the existing list as the first + entry. It will be the last one to be generated. */ + catch = build1 (CATCH_EXPR, void_type_node, catch_block); + TREE_CHAIN (catch) = catches; + catches = catch; + } + } + + node = build (TRY_EXPR, NULL_TREE, try_block, catches, finally); + EXPR_WFL_LINECOL (node) = location; + + /* If we have a finally, surround this whole thing by a block where + the RFF local variable is defined. */ + + return (finally ? build_expr_block (node, rff) : node); +} + +/* Get the catch clause block from an element of the catch clause + list. If depends on whether a finally clause exists or node (in + which case the original catch clause was surrounded by a + LABELED_BLOCK_EXPR. */ + +tree +java_get_catch_block (node, finally_present_p) + tree node; + int finally_present_p; +{ + return (CATCH_EXPR_GET_EXPR (TREE_OPERAND (node, 0), finally_present_p)); +} + +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 finally = TREE_OPERAND (node, 2); + int finally_p = (finally ? 1 : 0); + 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; + + /* Always detect the last catch clause if a finally is + present. This is the catch-all handler and it just needs to + be walked. */ + if (!TREE_CHAIN (current) && finally) + { + TREE_OPERAND (current, 0) = + java_complete_tree (TREE_OPERAND (current, 0)); + continue; + } + + /* At this point, the structure of the catch clause is + LABELED_BLOCK_EXPR (if we have a finally) + CATCH_EXPR (catch node) + BLOCK (with the decl of the parameter) + COMPOUND_EXPR + MODIFIY_EXPR (assignemnt of the catch parameter) + BLOCK (catch clause block) + LABEL_DECL (where to return after finally (if any)) + + Since the structure of the catch clause depends on the + presence of a finally, we use a function call to get to the + cath clause */ + catch_clause = java_get_catch_block (current, finally_p); + 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 = java_get_catch_block (sub_current, finally_p); + 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; + } + } + 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); + + /* Complete the catch clause block */ + catch_block = java_complete_tree (TREE_OPERAND (current, 0)); + if (catch_block == error_mark_node) + { + error_found = 1; + continue; + } + TREE_OPERAND (current, 0) = catch_block; + } + + PUSH_EXCEPTIONS (caught_type_list); + if ((try = java_complete_tree (try)) == error_mark_node) + error_found = 1; + POP_EXCEPTIONS (); + + /* Process finally */ + if (finally) + { + FINALLY_EXPR_BLOCK (finally) = + java_complete_tree (FINALLY_EXPR_BLOCK (finally)); + if (FINALLY_EXPR_BLOCK (finally) == error_mark_node) + error_found = 1; + } + + /* Verification ends here */ + if (error_found) + return error_mark_node; + + TREE_OPERAND (node, 0) = try; + TREE_OPERAND (node, 1) = catch; + TREE_OPERAND (node, 2) = finally; + 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 = TREE_OPERAND (node, 0); + tree block = TREE_OPERAND (node, 1); + tree try_block, catch_all, stmt, compound, decl; + + /* The TYPE of expr must be a reference type */ + if (!JREFERENCE_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 0)))) + { + 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); + } */ + + /* TRY block */ + BUILD_MONITOR_ENTER (stmt, expr); + compound = add_stmt_to_compound (NULL_TREE, int_type_node, stmt); + compound = add_stmt_to_compound (compound, void_type_node, block); + BUILD_MONITOR_EXIT (stmt, expr); + compound = add_stmt_to_compound (compound, int_type_node, stmt); + try_block = build_expr_block (compound, NULL_TREE); + + /* CATCH_ALL block */ + decl = build_decl_no_layout (VAR_DECL, generate_name (), ptr_type_node); + BUILD_ASSIGN_EXCEPTION_INFO (stmt, decl); + compound = add_stmt_to_compound (NULL_TREE, void_type_node, stmt); + BUILD_MONITOR_EXIT (stmt, expr); + compound = add_stmt_to_compound (compound, int_type_node, stmt); + BUILD_THROW (stmt, decl); + compound = add_stmt_to_compound (compound, void_type_node, stmt); + catch_all = build_expr_block (compound, decl); + catch_all = build_expr_block (catch_all, NULL_TREE); + catch_all = build1 (CATCH_EXPR, void_type_node, catch_all); + + /* TRY-CATCH statement */ + return build (TRY_EXPR, void_type_node, try_block, catch_all, NULL_TREE); +} + +/* 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_EXPRESSION_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 */ + else if (!EXCEPTIONS_P (currently_caught_type_list) + && !tryblock_throws_ok) + 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 a throw statement is contained in a static initializer, then a + compile-time check ensures that either its value is always an + unchecked exception or its value is always caught by some try + statement that contains it. FIXME, static initializer. */ + + 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))) + { + 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 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; + /* First, all the nested try-catch-finally at that stage. The + last element contains `throws' clause exceptions, if any. */ + 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_EXPRESSION_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; +} |