| blob | 154fef3f699e3c90e4f90c418c349fb275465aba |
1 /* Source code parsing and tree node generation for the GNU compiler
2 for the Java(TM) language.
3 Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* This file parses java source code and issues a tree node image
28 suitable for code generation (byte code and targeted CPU assembly
29 language).
31 The grammar conforms to the Java grammar described in "The Java(TM)
32 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
33 1996, ISBN 0-201-63451-1"
35 The following modifications were brought to the original grammar:
37 method_body: added the rule '| block SC_TK'
38 static_initializer: added the rule 'static block SC_TK'.
40 Note: All the extra rules described above should go away when the
41 empty_statement rule will work.
43 statement_nsi: 'nsi' should be read no_short_if.
45 Some rules have been modified to support JDK1.1 inner classes
46 definitions and other extensions. */
48 %{
51 #include <dirent.h>
69 #ifndef DIR_SEPARATOR
71 #endif
73 /* Local function prototypes */
94 ATTRIBUTE_PRINTF_2;
302 /* JDK 1.1 work. FIXME */
345 PTR));
347 PTR));
350 /* Number of error found so far. */
352 /* Number of warning found so far. */
354 /* Tell when not to fold, when doing xrefs */
356 /* Cyclic inheritance report, as it can be set by layout_class */
359 /* The current parser context */
362 /* List of things that were analyzed for which code will be generated */
365 /* binop_lookup maps token to tree_code. It is used where binary
366 operations are involved and required by the parser. RDIV_EXPR
367 covers both integral/floating point division. The code is changed
368 once the type of both operator is worked out. */
371 {
377 };
378 #define BINOP_LOOKUP(VALUE) \
381 /* This is the end index for binary operators that can also be used
382 in compound assignements. */
383 #define BINOP_COMPOUND_CANDIDATES 11
385 /* The "$L" identifier we use to create labels. */
388 /* The "StringBuffer" identifier used for the String `+' operator. */
391 /* The "append" identifier used for String `+' operator. */
394 /* The "toString" identifier used for String `+' operator. */
397 /* The "java.lang" import qualified name. */
400 /* The generated `inst$' identifier used for generated enclosing
401 instance/field access functions. */
404 /* The "java.lang.Cloneable" qualified name. */
407 /* The "java.io.Serializable" qualified name. */
410 /* Context and flag for static blocks */
413 /* The generated `write_parm_value$' identifier. */
416 /* The list of all packages we've seen so far */
419 /* Hold THIS for the scope of the current public method decl. */
422 /* Hold a list of catch clauses list. The first element of this list is
423 the list of the catch clauses of the currently analysed try block. */
428 /* All classes seen from source code */
429 #define gclass_list src_parse_roots[0]
431 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
432 line and point it out. */
433 /* Should point out the one that don't fit. ASCII/unicode, going
434 backward. FIXME */
436 #define check_modifiers(__message, __value, __mask) do { \
438 { \
444 } \
447 %}
450 tree node;
457 }
459 %{
461 %}
463 %pure_parser
465 /* Things defined here have to match the order of what's in the
466 binop_lookup table. */
468 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
469 %token LS_TK SRS_TK ZRS_TK
470 %token AND_TK XOR_TK OR_TK
471 %token BOOL_AND_TK BOOL_OR_TK
472 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
474 /* This maps to the same binop_lookup entry than the token above */
476 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
477 %token REM_ASSIGN_TK
478 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
479 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
482 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
484 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
485 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
486 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
487 %token PAD_TK ABSTRACT_TK MODIFIER_TK
488 %token STRICT_TK
490 /* Keep those two in order, too */
491 %token DECR_TK INCR_TK
493 /* From now one, things can be in any order */
495 %token DEFAULT_TK IF_TK THROW_TK
496 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
497 %token THROWS_TK BREAK_TK IMPORT_TK
498 %token ELSE_TK INSTANCEOF_TK RETURN_TK
499 %token VOID_TK CATCH_TK INTERFACE_TK
500 %token CASE_TK EXTENDS_TK FINALLY_TK
501 %token SUPER_TK WHILE_TK CLASS_TK
502 %token SWITCH_TK CONST_TK TRY_TK
503 %token FOR_TK NEW_TK CONTINUE_TK
504 %token GOTO_TK PACKAGE_TK THIS_TK
506 %token BYTE_TK SHORT_TK INT_TK LONG_TK
507 %token CHAR_TK INTEGRAL_TK
509 %token FLOAT_TK DOUBLE_TK FP_TK
511 %token ID_TK
513 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
515 %token ASSIGN_ANY_TK ASSIGN_TK
516 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
518 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
519 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
526 field_declaration method_declaration extends_interfaces
527 interfaces interface_type_list
528 class_member_declaration
529 import_declarations package_declaration
530 type_declarations interface_body
531 interface_member_declaration constant_declaration
532 interface_member_declarations interface_type
533 abstract_method_declaration interface_type_list
535 static_initializer constructor_declaration block
538 constructor_declarator explicit_constructor_invocation
542 variable_declarators variable_initializer
543 variable_initializers constructor_body
544 array_initializer
548 labeled_statement if_then_statement label_decl
549 if_then_else_statement while_statement for_statement
550 statement_nsi labeled_statement_nsi do_statement
551 if_then_else_statement_nsi while_statement_nsi
552 for_statement_nsi statement_expression_list for_init
553 for_update statement_expression expression_statement
554 primary_no_new_array expression primary
555 array_creation_expression array_type
556 class_instance_creation_expression field_access
557 method_invocation array_access something_dot_new
558 argument_list postfix_expression while_expression
559 post_increment_expression post_decrement_expression
560 unary_expression_not_plus_minus unary_expression
561 pre_increment_expression pre_decrement_expression
562 unary_expression_not_plus_minus cast_expression
563 multiplicative_expression additive_expression
564 shift_expression relational_expression
565 equality_expression and_expression
566 exclusive_or_expression inclusive_or_expression
567 conditional_and_expression conditional_or_expression
568 conditional_expression assignment_expression
569 left_hand_side assignment for_header for_begin
570 constant_expression do_statement_begin empty_statement
571 switch_statement synchronized_statement throw_statement
572 try_statement switch_expression switch_block
573 catches catch_clause catch_clause_parameter finally
574 anonymous_class_creation
594 STRING_LIT_TK NULL_TK VOID_TK
599 method_declarator method_header
602 BOOLEAN_TK INTEGRAL_TK FP_TK
604 /* Added or modified JDK 1.1 rule types */
607 %%
608 /* 19.2 Production from 2.3: The Syntactic Grammar */
609 goal:
610 {
611 /* Register static variables with the garbage
612 collector. */
628 mark_parser_ctxt);
631 mark_parser_ctxt);
632 }
633 compilation_unit
634 {}
635 ;
637 /* 19.3 Productions from 3: Lexical structure */
638 literal:
639 INT_LIT_TK
640 | FP_LIT_TK
641 | BOOL_LIT_TK
642 | CHAR_LIT_TK
643 | STRING_LIT_TK
644 | NULL_TK
645 ;
647 /* 19.4 Productions from 4: Types, Values and Variables */
648 type:
649 primitive_type
650 | reference_type
651 ;
653 primitive_type:
654 INTEGRAL_TK
655 | FP_TK
656 | BOOLEAN_TK
657 ;
659 reference_type:
660 class_or_interface_type
661 | array_type
662 ;
664 class_or_interface_type:
665 name
666 ;
668 class_type:
669 class_or_interface_type /* Default rule */
670 ;
672 interface_type:
673 class_or_interface_type
674 ;
676 array_type:
677 primitive_type dims
678 {
684 }
685 | name dims
686 {
692 }
693 ;
695 /* 19.5 Productions from 6: Names */
696 name:
697 simple_name /* Default rule */
698 | qualified_name /* Default rule */
699 ;
701 simple_name:
702 identifier /* Default rule */
703 ;
705 qualified_name:
706 name DOT_TK identifier
708 ;
710 identifier:
711 ID_TK
712 ;
714 /* 19.6: Production from 7: Packages */
715 compilation_unit:
717 | package_declaration
718 | import_declarations
719 | type_declarations
720 | package_declaration import_declarations
721 | package_declaration type_declarations
722 | import_declarations type_declarations
723 | package_declaration import_declarations type_declarations
724 ;
726 import_declarations:
727 import_declaration
728 {
730 }
731 | import_declarations import_declaration
732 {
734 }
735 ;
737 type_declarations:
738 type_declaration
739 | type_declarations type_declaration
740 ;
742 package_declaration:
743 PACKAGE_TK name SC_TK
744 {
747 }
748 | PACKAGE_TK error
750 | PACKAGE_TK name error
752 ;
754 import_declaration:
755 single_type_import_declaration
756 | type_import_on_demand_declaration
757 ;
759 single_type_import_declaration:
760 IMPORT_TK name SC_TK
761 {
766 {
768 break;
769 last--;
770 }
773 {
776 parse_error_context
780 else
782 }
783 else
785 }
786 | IMPORT_TK error
788 | IMPORT_TK name error
790 ;
792 type_import_on_demand_declaration:
793 IMPORT_TK name DOT_TK MULT_TK SC_TK
794 {
796 tree it;
797 /* Search for duplicates. */
800 break;
801 /* Don't import the same thing more than once, just ignore
802 duplicates (7.5.2) */
804 {
809 }
810 }
811 | IMPORT_TK name DOT_TK error
813 | IMPORT_TK name DOT_TK MULT_TK error
815 ;
817 type_declaration:
818 class_declaration
820 | interface_declaration
822 | empty_statement
823 | error
824 {
825 YYERROR_NOW;
827 }
828 ;
830 /* 19.7 Shortened from the original:
831 modifiers: modifier | modifiers modifier
832 modifier: any of public... */
833 modifiers:
834 MODIFIER_TK
835 {
837 }
838 | modifiers MODIFIER_TK
839 {
842 parse_error_context
845 else
846 {
848 }
849 }
850 ;
852 /* 19.8.1 Production from $8.1: Class Declaration */
853 class_declaration:
854 modifiers CLASS_TK identifier super interfaces
856 class_body
857 | CLASS_TK identifier super interfaces
859 class_body
860 | modifiers CLASS_TK error
862 | CLASS_TK error
864 | CLASS_TK identifier error
865 {
868 }
869 | modifiers CLASS_TK identifier error
871 ;
873 super:
875 | EXTENDS_TK class_type
877 | EXTENDS_TK class_type error
879 | EXTENDS_TK error
881 ;
883 interfaces:
885 | IMPLEMENTS_TK interface_type_list
887 | IMPLEMENTS_TK error
888 {
891 }
892 ;
894 interface_type_list:
895 interface_type
896 {
899 }
900 | interface_type_list C_TK interface_type
901 {
904 }
905 | interface_type_list C_TK error
907 ;
909 class_body:
910 OCB_TK CCB_TK
911 {
912 /* Store the location of the `}' when doing xrefs */
917 }
918 | OCB_TK class_body_declarations CCB_TK
919 {
920 /* Store the location of the `}' when doing xrefs */
925 }
926 ;
928 class_body_declarations:
929 class_body_declaration
930 | class_body_declarations class_body_declaration
931 ;
933 class_body_declaration:
934 class_member_declaration
935 | static_initializer
936 | constructor_declaration
937 | block /* Added, JDK1.1, instance initializer */
938 {
940 {
943 }
944 }
945 ;
947 class_member_declaration:
948 field_declaration
949 | method_declaration
950 | class_declaration /* Added, JDK1.1 inner classes */
952 | interface_declaration /* Added, JDK1.1 inner interfaces */
954 | empty_statement
955 ;
957 /* 19.8.2 Productions from 8.3: Field Declarations */
958 field_declaration:
959 type variable_declarators SC_TK
961 | modifiers type variable_declarators SC_TK
962 {
963 check_modifiers
968 }
969 ;
971 variable_declarators:
972 /* Should we use build_decl_list () instead ? FIXME */
973 variable_declarator /* Default rule */
974 | variable_declarators C_TK variable_declarator
976 | variable_declarators C_TK error
978 ;
980 variable_declarator:
981 variable_declarator_id
983 | variable_declarator_id ASSIGN_TK variable_initializer
984 {
987 $$ = build_tree_list
989 }
990 | variable_declarator_id ASSIGN_TK error
991 {
994 RECOVER;
995 }
996 | variable_declarator_id ASSIGN_TK variable_initializer error
997 {
1000 RECOVER;
1001 }
1002 ;
1004 variable_declarator_id:
1005 identifier
1006 | variable_declarator_id OSB_TK CSB_TK
1008 | identifier error
1010 | variable_declarator_id OSB_TK error
1011 {
1016 else
1019 }
1020 | variable_declarator_id CSB_TK error
1022 ;
1024 variable_initializer:
1025 expression
1026 | array_initializer
1027 ;
1029 /* 19.8.3 Productions from 8.4: Method Declarations */
1030 method_declaration:
1031 method_header
1032 {
1034 if (current_function_decl
1037 else
1039 }
1040 method_body
1042 | method_header error
1044 ;
1046 method_header:
1047 type method_declarator throws
1049 | VOID_TK method_declarator throws
1051 | modifiers type method_declarator throws
1053 | modifiers VOID_TK method_declarator throws
1055 | type error
1056 {
1058 RECOVER;
1059 }
1060 | modifiers type error
1062 | VOID_TK error
1064 | modifiers VOID_TK error
1066 | modifiers error
1067 {
1069 RECOVER;
1070 }
1071 ;
1073 method_declarator:
1074 identifier OP_TK CP_TK
1075 {
1078 }
1079 | identifier OP_TK formal_parameter_list CP_TK
1081 | method_declarator OSB_TK CSB_TK
1082 {
1086 parse_warning_context
1089 }
1090 | identifier OP_TK error
1092 | method_declarator OSB_TK error
1094 ;
1096 formal_parameter_list:
1097 formal_parameter
1098 {
1100 }
1101 | formal_parameter_list C_TK formal_parameter
1102 {
1105 }
1106 | formal_parameter_list C_TK error
1108 ;
1110 formal_parameter:
1111 type variable_declarator_id
1112 {
1114 }
1115 | final type variable_declarator_id /* Added, JDK1.1 final parms */
1116 {
1119 }
1120 | type error
1121 {
1124 }
1125 | final type error
1126 {
1129 }
1130 ;
1132 final:
1133 modifiers
1134 {
1139 }
1140 ;
1142 throws:
1144 | THROWS_TK class_type_list
1146 | THROWS_TK error
1148 ;
1150 class_type_list:
1151 class_type
1153 | class_type_list C_TK class_type
1155 | class_type_list C_TK error
1157 ;
1159 method_body:
1160 block
1162 ;
1164 /* 19.8.4 Productions from 8.5: Static Initializers */
1165 static_initializer:
1166 static block
1167 {
1171 }
1172 ;
1175 modifiers
1176 {
1178 /* Can't have a static initializer in an innerclass */
1181 parse_error_context
1183 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1186 }
1187 ;
1189 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1190 constructor_declaration:
1191 constructor_header
1192 {
1195 }
1196 constructor_body
1198 ;
1200 constructor_header:
1201 constructor_declarator throws
1203 | modifiers constructor_declarator throws
1205 ;
1207 constructor_declarator:
1208 simple_name OP_TK CP_TK
1209 {
1212 }
1213 | simple_name OP_TK formal_parameter_list CP_TK
1215 ;
1217 constructor_body:
1218 /* Unlike regular method, we always need a complete (empty)
1219 body so we can safely perform all the required code
1220 addition (super invocation and field initialization) */
1221 block_begin constructor_block_end
1222 {
1225 }
1226 | block_begin explicit_constructor_invocation constructor_block_end
1228 | block_begin block_statements constructor_block_end
1230 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1232 ;
1234 constructor_block_end:
1235 block_end
1236 ;
1238 /* Error recovery for that rule moved down expression_statement: rule. */
1239 explicit_constructor_invocation:
1240 this_or_super OP_TK CP_TK SC_TK
1241 {
1245 }
1246 | this_or_super OP_TK argument_list CP_TK SC_TK
1247 {
1251 }
1252 /* Added, JDK1.1 inner classes. Modified because the rule
1253 'primary' couldn't work. */
1254 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1256 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1258 ;
1261 THIS_TK
1262 {
1266 }
1267 | SUPER_TK
1268 {
1272 }
1273 ;
1275 /* 19.9 Productions from 9: Interfaces */
1276 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1277 interface_declaration:
1278 INTERFACE_TK identifier
1280 interface_body
1281 | modifiers INTERFACE_TK identifier
1283 interface_body
1284 | INTERFACE_TK identifier extends_interfaces
1286 interface_body
1287 | modifiers INTERFACE_TK identifier extends_interfaces
1289 interface_body
1290 | INTERFACE_TK identifier error
1292 | modifiers INTERFACE_TK identifier error
1294 ;
1296 extends_interfaces:
1297 EXTENDS_TK interface_type
1298 {
1301 }
1302 | extends_interfaces C_TK interface_type
1303 {
1306 }
1307 | EXTENDS_TK error
1309 | extends_interfaces C_TK error
1311 ;
1313 interface_body:
1314 OCB_TK CCB_TK
1316 | OCB_TK interface_member_declarations CCB_TK
1318 ;
1320 interface_member_declarations:
1321 interface_member_declaration
1322 | interface_member_declarations interface_member_declaration
1323 ;
1325 interface_member_declaration:
1326 constant_declaration
1327 | abstract_method_declaration
1328 | class_declaration /* Added, JDK1.1 inner classes */
1330 | interface_declaration /* Added, JDK1.1 inner interfaces */
1332 ;
1334 constant_declaration:
1335 field_declaration
1336 ;
1338 abstract_method_declaration:
1339 method_header SC_TK
1340 {
1343 }
1344 | method_header error
1346 ;
1348 /* 19.10 Productions from 10: Arrays */
1349 array_initializer:
1350 OCB_TK CCB_TK
1352 | OCB_TK C_TK CCB_TK
1354 | OCB_TK variable_initializers CCB_TK
1356 | OCB_TK variable_initializers C_TK CCB_TK
1358 ;
1360 variable_initializers:
1361 variable_initializer
1362 {
1365 }
1366 | variable_initializers C_TK variable_initializer
1367 {
1369 }
1370 | variable_initializers C_TK error
1372 ;
1374 /* 19.11 Production from 14: Blocks and Statements */
1375 block:
1376 OCB_TK CCB_TK
1377 {
1378 /* Store the location of the `}' when doing xrefs */
1383 }
1384 | block_begin block_statements block_end
1386 ;
1388 block_begin:
1389 OCB_TK
1391 ;
1393 block_end:
1394 CCB_TK
1395 {
1396 maybe_absorb_scoping_blocks ();
1397 /* Store the location of the `}' when doing xrefs */
1404 }
1405 ;
1407 block_statements:
1408 block_statement
1409 | block_statements block_statement
1410 ;
1412 block_statement:
1413 local_variable_declaration_statement
1414 | statement
1416 | class_declaration /* Added, JDK1.1 local classes */
1417 {
1420 }
1421 ;
1423 local_variable_declaration_statement:
1424 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1425 ;
1427 local_variable_declaration:
1428 type variable_declarators
1430 | final type variable_declarators /* Added, JDK1.1 final locals */
1432 ;
1434 statement:
1435 statement_without_trailing_substatement
1436 | labeled_statement
1437 | if_then_statement
1438 | if_then_else_statement
1439 | while_statement
1440 | for_statement
1442 ;
1444 statement_nsi:
1445 statement_without_trailing_substatement
1446 | labeled_statement_nsi
1447 | if_then_else_statement_nsi
1448 | while_statement_nsi
1449 | for_statement_nsi
1451 ;
1453 statement_without_trailing_substatement:
1454 block
1455 | empty_statement
1456 | expression_statement
1457 | switch_statement
1458 | do_statement
1459 | break_statement
1460 | continue_statement
1461 | return_statement
1462 | synchronized_statement
1463 | throw_statement
1464 | try_statement
1465 ;
1467 empty_statement:
1468 SC_TK
1469 {
1470 if (flag_extraneous_semicolon
1471 && ! current_static_block
1472 && (! current_function_decl ||
1473 /* Verify we're not in a inner class declaration */
1477 {
1479 parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1480 }
1482 }
1483 ;
1485 label_decl:
1486 identifier REL_CL_TK
1487 {
1493 }
1494 ;
1496 labeled_statement:
1497 label_decl statement
1499 | identifier error
1501 ;
1503 labeled_statement_nsi:
1504 label_decl statement_nsi
1506 ;
1508 /* We concentrate here a bunch of error handling rules that we couldn't write
1509 earlier, because expression_statement catches a missing ';'. */
1510 expression_statement:
1511 statement_expression SC_TK
1512 {
1513 /* We have a statement. Generate a WFL around it so
1514 we can debug it */
1516 /* We know we have a statement, so set the debug
1517 info to be eventually generate here. */
1519 }
1520 | error SC_TK
1521 {
1524 }
1525 | error OCB_TK
1526 {
1529 }
1530 | error CCB_TK
1531 {
1534 }
1535 | this_or_super OP_TK error
1537 | this_or_super OP_TK CP_TK error
1538 {
1539 parse_ctor_invocation_error ();
1540 RECOVER;
1541 }
1542 | this_or_super OP_TK argument_list error
1544 | this_or_super OP_TK argument_list CP_TK error
1545 {
1546 parse_ctor_invocation_error ();
1547 RECOVER;
1548 }
1549 | name DOT_TK SUPER_TK error
1551 | name DOT_TK SUPER_TK OP_TK error
1553 | name DOT_TK SUPER_TK OP_TK argument_list error
1555 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1557 | name DOT_TK SUPER_TK OP_TK CP_TK error
1559 ;
1561 statement_expression:
1562 assignment
1563 | pre_increment_expression
1564 | pre_decrement_expression
1565 | post_increment_expression
1566 | post_decrement_expression
1567 | method_invocation
1568 | class_instance_creation_expression
1569 ;
1571 if_then_statement:
1572 IF_TK OP_TK expression CP_TK statement
1573 {
1576 }
1577 | IF_TK error
1579 | IF_TK OP_TK error
1581 | IF_TK OP_TK expression error
1583 ;
1585 if_then_else_statement:
1586 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1588 ;
1590 if_then_else_statement_nsi:
1591 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1593 ;
1595 switch_statement:
1596 switch_expression
1597 {
1598 enter_block ();
1599 }
1600 switch_block
1601 {
1602 /* Make into "proper list" of COMPOUND_EXPRs.
1603 I.e. make the last statment also have its own
1604 COMPOUND_EXPR. */
1605 maybe_absorb_scoping_blocks ();
1608 }
1609 ;
1611 switch_expression:
1612 SWITCH_TK OP_TK expression CP_TK
1613 {
1616 }
1617 | SWITCH_TK error
1619 | SWITCH_TK OP_TK error
1621 | SWITCH_TK OP_TK expression CP_TK error
1623 ;
1625 /* Default assignment is there to avoid type node on switch_block
1626 node. */
1628 switch_block:
1629 OCB_TK CCB_TK
1631 | OCB_TK switch_labels CCB_TK
1633 | OCB_TK switch_block_statement_groups CCB_TK
1635 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1637 ;
1639 switch_block_statement_groups:
1640 switch_block_statement_group
1641 | switch_block_statement_groups switch_block_statement_group
1642 ;
1644 switch_block_statement_group:
1645 switch_labels block_statements
1646 ;
1648 switch_labels:
1649 switch_label
1650 | switch_labels switch_label
1651 ;
1653 switch_label:
1654 CASE_TK constant_expression REL_CL_TK
1655 {
1659 }
1660 | DEFAULT_TK REL_CL_TK
1661 {
1665 }
1666 | CASE_TK error
1668 | CASE_TK constant_expression error
1670 | DEFAULT_TK error
1672 ;
1674 while_expression:
1675 WHILE_TK OP_TK expression CP_TK
1676 {
1679 }
1680 ;
1682 while_statement:
1683 while_expression statement
1685 | WHILE_TK error
1687 | WHILE_TK OP_TK error
1689 | WHILE_TK OP_TK expression error
1691 ;
1693 while_statement_nsi:
1694 while_expression statement_nsi
1696 ;
1698 do_statement_begin:
1699 DO_TK
1700 {
1703 }
1704 /* Need error handing here. FIXME */
1705 ;
1707 do_statement:
1708 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1710 ;
1712 for_statement:
1713 for_begin SC_TK expression SC_TK for_update CP_TK statement
1714 {
1718 }
1719 | for_begin SC_TK SC_TK for_update CP_TK statement
1720 {
1722 /* We have not condition, so we get rid of the EXIT_EXPR */
1724 empty_stmt_node;
1725 }
1726 | for_begin SC_TK error
1728 | for_begin SC_TK expression SC_TK error
1730 | for_begin SC_TK SC_TK error
1732 ;
1734 for_statement_nsi:
1735 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1737 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1738 {
1740 /* We have not condition, so we get rid of the EXIT_EXPR */
1742 empty_stmt_node;
1743 }
1744 ;
1746 for_header:
1747 FOR_TK OP_TK
1748 {
1749 /* This scope defined for local variable that may be
1750 defined within the scope of the for loop */
1751 enter_block ();
1752 }
1753 | FOR_TK error
1755 | FOR_TK OP_TK error
1757 ;
1759 for_begin:
1760 for_header for_init
1761 {
1762 /* We now declare the loop body. The loop is
1763 declared as a for loop. */
1767 /* The loop is added to the current block the for
1768 statement is defined within */
1770 }
1771 ;
1774 | statement_expression_list
1775 {
1776 /* Init statement recorded within the previously
1777 defined block scope */
1779 }
1780 | local_variable_declaration
1781 {
1782 /* Local variable are recorded within the previously
1783 defined block scope */
1785 }
1786 | statement_expression_list error
1788 ;
1792 | statement_expression_list
1794 ;
1796 statement_expression_list:
1797 statement_expression
1799 | statement_expression_list C_TK statement_expression
1801 | statement_expression_list C_TK error
1803 ;
1805 break_statement:
1806 BREAK_TK SC_TK
1808 | BREAK_TK identifier SC_TK
1810 | BREAK_TK error
1812 | BREAK_TK identifier error
1814 ;
1816 continue_statement:
1817 CONTINUE_TK SC_TK
1819 | CONTINUE_TK identifier SC_TK
1821 | CONTINUE_TK error
1823 | CONTINUE_TK identifier error
1825 ;
1827 return_statement:
1828 RETURN_TK SC_TK
1830 | RETURN_TK expression SC_TK
1832 | RETURN_TK error
1834 | RETURN_TK expression error
1836 ;
1838 throw_statement:
1839 THROW_TK expression SC_TK
1840 {
1843 }
1844 | THROW_TK error
1846 | THROW_TK expression error
1848 ;
1850 synchronized_statement:
1851 synchronized OP_TK expression CP_TK block
1852 {
1856 }
1857 | synchronized OP_TK expression CP_TK error
1859 | synchronized error
1861 | synchronized OP_TK error CP_TK
1863 | synchronized OP_TK error
1865 ;
1867 synchronized:
1868 modifiers
1869 {
1870 check_modifiers (
1876 }
1877 ;
1879 try_statement:
1880 TRY_TK block catches
1882 | TRY_TK block finally
1884 | TRY_TK block catches finally
1888 }
1889 | TRY_TK error
1891 ;
1893 catches:
1894 catch_clause
1895 | catches catch_clause
1896 {
1899 }
1900 ;
1902 catch_clause:
1903 catch_clause_parameter block
1904 {
1906 exit_block ();
1908 }
1910 catch_clause_parameter:
1911 CATCH_TK OP_TK formal_parameter CP_TK
1912 {
1913 /* We add a block to define a scope for
1914 formal_parameter (CCBP). The formal parameter is
1915 declared initialized by the appropriate function
1916 call */
1918 tree init = build_assignment
1923 init));
1926 }
1927 | CATCH_TK error
1929 | CATCH_TK OP_TK error
1930 {
1933 }
1936 ;
1938 finally:
1939 FINALLY_TK block
1941 | FINALLY_TK error
1943 ;
1945 /* 19.12 Production from 15: Expressions */
1946 primary:
1947 primary_no_new_array
1948 | array_creation_expression
1949 ;
1951 primary_no_new_array:
1952 literal
1953 | THIS_TK
1955 | OP_TK expression CP_TK
1957 | class_instance_creation_expression
1958 | field_access
1959 | method_invocation
1960 | array_access
1961 | type_literals
1962 /* Added, JDK1.1 inner classes. Documentation is wrong
1963 refering to a 'ClassName' (class_name) rule that doesn't
1964 exist. Used name: instead. */
1965 | name DOT_TK THIS_TK
1966 {
1969 }
1970 | OP_TK expression error
1972 | name DOT_TK error
1974 | primitive_type DOT_TK error
1976 | VOID_TK DOT_TK error
1978 ;
1980 type_literals:
1981 name DOT_TK CLASS_TK
1983 | array_type DOT_TK CLASS_TK
1985 | primitive_type DOT_TK CLASS_TK
1987 | VOID_TK DOT_TK CLASS_TK
1988 {
1990 void_type_node);
1991 }
1992 ;
1994 class_instance_creation_expression:
1995 NEW_TK class_type OP_TK argument_list CP_TK
1997 | NEW_TK class_type OP_TK CP_TK
1999 | anonymous_class_creation
2000 /* Added, JDK1.1 inner classes, modified to use name or
2001 primary instead of primary solely which couldn't work in
2002 all situations. */
2003 | something_dot_new identifier OP_TK CP_TK
2004 {
2008 }
2009 | something_dot_new identifier OP_TK CP_TK class_body
2010 | something_dot_new identifier OP_TK argument_list CP_TK
2011 {
2015 }
2016 | something_dot_new identifier OP_TK argument_list CP_TK class_body
2017 | NEW_TK error SC_TK
2019 | NEW_TK class_type error
2021 | NEW_TK class_type OP_TK error
2023 | NEW_TK class_type OP_TK argument_list error
2025 | something_dot_new error
2027 | something_dot_new identifier error
2029 ;
2031 /* Created after JDK1.1 rules originally added to
2032 class_instance_creation_expression, but modified to use
2033 'class_type' instead of 'TypeName' (type_name) which is mentionned
2034 in the documentation but doesn't exist. */
2036 anonymous_class_creation:
2037 NEW_TK class_type OP_TK argument_list CP_TK
2039 class_body
2040 {
2046 /* Now we can craft the new expression */
2049 /* Note that we can't possibly be here if
2050 `class_type' is an interface (in which case the
2051 anonymous class extends Object and implements
2052 `class_type', hence its constructor can't have
2053 arguments.) */
2055 /* Otherwise, the innerclass must feature a
2056 constructor matching `argument_list'. Anonymous
2057 classes are a bit special: it's impossible to
2058 define constructor for them, hence constructors
2059 must be generated following the hints provided by
2060 the `new' expression. Whether a super constructor
2061 of that nature exists or not is to be verified
2062 later on in verify_constructor_super.
2064 It's during the expansion of a `new' statement
2065 refering to an anonymous class that a ctor will
2066 be generated for the anonymous class, with the
2067 right arguments. */
2069 }
2070 | NEW_TK class_type OP_TK CP_TK
2072 class_body
2073 {
2079 /* Now we can craft the new expression. The
2080 statement doesn't need to be remember so that a
2081 constructor can be generated, since its signature
2082 is already known. */
2084 }
2085 ;
2088 name DOT_TK NEW_TK
2090 | primary DOT_TK NEW_TK
2092 ;
2094 argument_list:
2095 expression
2096 {
2099 }
2100 | argument_list C_TK expression
2101 {
2104 }
2105 | argument_list C_TK error
2107 ;
2109 array_creation_expression:
2110 NEW_TK primitive_type dim_exprs
2112 | NEW_TK class_or_interface_type dim_exprs
2114 | NEW_TK primitive_type dim_exprs dims
2116 | NEW_TK class_or_interface_type dim_exprs dims
2118 /* Added, JDK1.1 anonymous array. Initial documentation rule
2119 modified */
2120 | NEW_TK class_or_interface_type dims array_initializer
2121 {
2130 }
2131 | NEW_TK primitive_type dims array_initializer
2132 {
2139 }
2140 | NEW_TK error CSB_TK
2142 | NEW_TK error OSB_TK
2144 ;
2146 dim_exprs:
2147 dim_expr
2149 | dim_exprs dim_expr
2151 ;
2153 dim_expr:
2154 OSB_TK expression CSB_TK
2155 {
2157 {
2160 }
2163 }
2164 | OSB_TK expression error
2166 | OSB_TK error
2167 {
2170 RECOVER;
2171 }
2172 ;
2174 dims:
2175 OSB_TK CSB_TK
2176 {
2178 /* If not initialized, allocate memory for the osb
2179 numbers stack */
2181 {
2184 }
2185 /* If capacity overflown, reallocate a bigger chunk */
2190 {
2194 allocate);
2195 else
2197 }
2200 }
2201 | dims OSB_TK CSB_TK
2203 | dims OSB_TK error
2205 ;
2207 field_access:
2208 primary DOT_TK identifier
2210 /* FIXME - REWRITE TO:
2211 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2212 | SUPER_TK DOT_TK identifier
2213 {
2217 }
2218 | SUPER_TK error
2220 ;
2222 method_invocation:
2223 name OP_TK CP_TK
2225 | name OP_TK argument_list CP_TK
2227 | primary DOT_TK identifier OP_TK CP_TK
2228 {
2230 $$ = build_this_super_qualified_invocation
2232 else
2233 {
2236 }
2237 }
2238 | primary DOT_TK identifier OP_TK argument_list CP_TK
2239 {
2241 $$ = build_this_super_qualified_invocation
2243 else
2244 {
2247 }
2248 }
2249 | SUPER_TK DOT_TK identifier OP_TK CP_TK
2250 {
2251 $$ = build_this_super_qualified_invocation
2253 }
2254 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2255 {
2256 $$ = build_this_super_qualified_invocation
2258 }
2259 /* Screws up thing. I let it here until I'm convinced it can
2260 be removed. FIXME
2261 | primary DOT_TK error
2262 {yyerror ("'(' expected"); DRECOVER(bad);} */
2263 | SUPER_TK DOT_TK error CP_TK
2265 | SUPER_TK DOT_TK error DOT_TK
2267 ;
2269 array_access:
2270 name OSB_TK expression CSB_TK
2272 | primary_no_new_array OSB_TK expression CSB_TK
2274 | name OSB_TK error
2275 {
2278 }
2279 | name OSB_TK expression error
2280 {
2283 }
2284 | primary_no_new_array OSB_TK error
2285 {
2288 }
2289 | primary_no_new_array OSB_TK expression error
2290 {
2293 }
2294 ;
2296 postfix_expression:
2297 primary
2298 | name
2299 | post_increment_expression
2300 | post_decrement_expression
2301 ;
2303 post_increment_expression:
2304 postfix_expression INCR_TK
2306 ;
2308 post_decrement_expression:
2309 postfix_expression DECR_TK
2311 ;
2313 unary_expression:
2314 pre_increment_expression
2315 | pre_decrement_expression
2316 | PLUS_TK unary_expression
2318 | MINUS_TK unary_expression
2320 | unary_expression_not_plus_minus
2321 | PLUS_TK error
2323 | MINUS_TK error
2325 ;
2327 pre_increment_expression:
2328 INCR_TK unary_expression
2330 | INCR_TK error
2332 ;
2334 pre_decrement_expression:
2335 DECR_TK unary_expression
2337 | DECR_TK error
2339 ;
2341 unary_expression_not_plus_minus:
2342 postfix_expression
2343 | NOT_TK unary_expression
2345 | NEG_TK unary_expression
2347 | cast_expression
2348 | NOT_TK error
2350 | NEG_TK error
2352 ;
2355 OP_TK primitive_type dims CP_TK unary_expression
2356 {
2362 }
2363 | OP_TK primitive_type CP_TK unary_expression
2365 | OP_TK expression CP_TK unary_expression_not_plus_minus
2367 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2368 {
2380 }
2381 | OP_TK primitive_type OSB_TK error
2383 | OP_TK error
2384 {
2386 RECOVER;
2387 }
2388 | OP_TK primitive_type dims CP_TK error
2390 | OP_TK primitive_type CP_TK error
2392 | OP_TK name dims CP_TK error
2394 ;
2396 multiplicative_expression:
2397 unary_expression
2398 | multiplicative_expression MULT_TK unary_expression
2399 {
2402 }
2403 | multiplicative_expression DIV_TK unary_expression
2404 {
2407 }
2408 | multiplicative_expression REM_TK unary_expression
2409 {
2412 }
2413 | multiplicative_expression MULT_TK error
2415 | multiplicative_expression DIV_TK error
2417 | multiplicative_expression REM_TK error
2419 ;
2421 additive_expression:
2422 multiplicative_expression
2423 | additive_expression PLUS_TK multiplicative_expression
2424 {
2427 }
2428 | additive_expression MINUS_TK multiplicative_expression
2429 {
2432 }
2433 | additive_expression PLUS_TK error
2435 | additive_expression MINUS_TK error
2437 ;
2439 shift_expression:
2440 additive_expression
2441 | shift_expression LS_TK additive_expression
2442 {
2445 }
2446 | shift_expression SRS_TK additive_expression
2447 {
2450 }
2451 | shift_expression ZRS_TK additive_expression
2452 {
2455 }
2456 | shift_expression LS_TK error
2458 | shift_expression SRS_TK error
2460 | shift_expression ZRS_TK error
2462 ;
2464 relational_expression:
2465 shift_expression
2466 | relational_expression LT_TK shift_expression
2467 {
2470 }
2471 | relational_expression GT_TK shift_expression
2472 {
2475 }
2476 | relational_expression LTE_TK shift_expression
2477 {
2480 }
2481 | relational_expression GTE_TK shift_expression
2482 {
2485 }
2486 | relational_expression INSTANCEOF_TK reference_type
2488 | relational_expression LT_TK error
2490 | relational_expression GT_TK error
2492 | relational_expression LTE_TK error
2494 | relational_expression GTE_TK error
2496 | relational_expression INSTANCEOF_TK error
2498 ;
2500 equality_expression:
2501 relational_expression
2502 | equality_expression EQ_TK relational_expression
2503 {
2506 }
2507 | equality_expression NEQ_TK relational_expression
2508 {
2511 }
2512 | equality_expression EQ_TK error
2514 | equality_expression NEQ_TK error
2516 ;
2518 and_expression:
2519 equality_expression
2520 | and_expression AND_TK equality_expression
2521 {
2524 }
2525 | and_expression AND_TK error
2527 ;
2529 exclusive_or_expression:
2530 and_expression
2531 | exclusive_or_expression XOR_TK and_expression
2532 {
2535 }
2536 | exclusive_or_expression XOR_TK error
2538 ;
2540 inclusive_or_expression:
2541 exclusive_or_expression
2542 | inclusive_or_expression OR_TK exclusive_or_expression
2543 {
2546 }
2547 | inclusive_or_expression OR_TK error
2549 ;
2551 conditional_and_expression:
2552 inclusive_or_expression
2553 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2554 {
2557 }
2558 | conditional_and_expression BOOL_AND_TK error
2560 ;
2562 conditional_or_expression:
2563 conditional_and_expression
2564 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2565 {
2568 }
2569 | conditional_or_expression BOOL_OR_TK error
2571 ;
2574 conditional_or_expression
2575 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2576 {
2579 }
2580 | conditional_or_expression REL_QM_TK REL_CL_TK error
2581 {
2582 YYERROR_NOW;
2585 }
2586 | conditional_or_expression REL_QM_TK error
2588 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2590 ;
2592 assignment_expression:
2593 conditional_expression
2594 | assignment
2595 ;
2597 assignment:
2598 left_hand_side assignment_operator assignment_expression
2600 | left_hand_side assignment_operator error
2601 {
2604 }
2605 ;
2607 left_hand_side:
2608 name
2609 | field_access
2610 | array_access
2611 ;
2613 assignment_operator:
2614 ASSIGN_ANY_TK
2615 | ASSIGN_TK
2616 ;
2618 expression:
2619 assignment_expression
2620 ;
2622 constant_expression:
2623 expression
2624 ;
2626 %%
2628 /* Helper function to retrieve an OSB count. Should be used when the
2629 `dims:' rule is being used. */
2631 static int
2634 {
2638 abort ();
2643 return to_return;
2644 }
2646 \f
2648 /* This section of the code deal with save/restoring parser contexts.
2649 Add mode documentation here. FIXME */
2651 /* Helper function. Create a new parser context. With
2652 COPY_FROM_PREVIOUS set to a non zero value, content of the previous
2653 context is copied, otherwise, the new context is zeroed. The newly
2654 created context becomes the current one. */
2656 static void
2659 {
2664 {
2667 }
2668 else
2673 }
2675 /* Create a new parser context and make it the current one. */
2677 void
2678 java_push_parser_context ()
2679 {
2681 }
2683 void
2686 {
2687 tree current;
2691 return;
2696 {
2699 }
2701 /* If the old and new lexers differ, then free the old one. */
2705 /* Set the single import class file flag to 0 for the current list
2706 of imported things */
2710 /* And restore those of the previous context */
2715 /* If we pushed a context to parse a class intended to be generated,
2716 we keep it so we can remember the class. What we could actually
2717 do is to just update a list of class names. */
2719 {
2722 }
2723 else
2725 }
2727 /* Create a parser context for the use of saving some global
2728 variables. */
2730 void
2731 java_parser_context_save_global ()
2732 {
2734 {
2735 java_push_parser_context ();
2737 }
2739 /* If this context already stores data, create a new one suitable
2740 for data storage. */
2749 }
2751 /* Restore some global variables from the previous context. Make the
2752 previous context the current one. */
2754 void
2755 java_parser_context_restore_global ()
2756 {
2761 {
2762 tree s;
2765 }
2770 }
2772 /* Suspend vital data for the current class/function being parsed so
2773 that an other class can be parsed. Used to let local/anonymous
2774 classes be parsed. */
2776 static void
2777 java_parser_context_suspend ()
2778 {
2779 /* This makes debugging through java_debug_context easier */
2782 /* Duplicate the previous context, use it to save the globals we're
2783 interested in */
2788 /* Then create a new context which inherits all data from the
2789 previous one. This will be the new current context */
2792 /* Help debugging */
2794 }
2796 /* Resume vital data for the current class/function being parsed so
2797 that an other class can be parsed. Used to let local/anonymous
2798 classes be parsed. The trick is the data storing file position
2799 informations must be restored to their current value, so parsing
2800 can resume as if no context was ever saved. */
2802 static void
2803 java_parser_context_resume ()
2804 {
2809 /* We need to inherit the list of classes to complete/generate */
2813 /* Restore the current class and function from the saver */
2817 /* Retrive the restored context */
2820 /* Re-installed the data for the parsing to carry on */
2824 /* Buffer context can now be discarded */
2827 }
2829 /* Add a new anchor node to which all statement(s) initializing static
2830 and non static initialized upon declaration field(s) will be
2831 linked. */
2833 static void
2834 java_parser_context_push_initialized_field ()
2835 {
2836 tree node;
2849 }
2851 /* Pop the lists of initialized field. If this lists aren't empty,
2852 remember them so we can use it to create and populate the finit$
2853 or <clinit> functions. */
2855 static void
2856 java_parser_context_pop_initialized_field ()
2857 {
2858 tree stmts;
2862 {
2867 }
2870 {
2874 /* Keep initialization in order to enforce 8.5 */
2877 }
2879 /* JDK 1.1 instance initializers */
2881 {
2887 }
2888 }
2890 static tree
2892 tree list;
2893 {
2894 /* We have to keep things in order. The alias initializer have to
2895 come first, then the initialized regular field, in reverse to
2896 keep them in lexical order. */
2901 break;
2903 /* No static initialized, the list is fine as is */
2907 /* No marker? reverse the whole list */
2911 /* Otherwise, reverse what's after the marker and the new reordered
2912 sublist will replace the marker. */
2913 else
2914 {
2918 }
2919 return list;
2920 }
2922 /* Helper functions to dump the parser context stack. */
2924 #define TAB_CONTEXT(C) \
2927 static void
2930 {
2933 {
2950 }
2951 }
2953 /* Dump the stacked up parser contexts. Intended to be called from a
2954 debugger. */
2956 void
2957 java_debug_context ()
2958 {
2960 }
2962 \f
2964 /* Flag for the error report routine to issue the error the first time
2965 it's called (overriding the default behavior which is to drop the
2966 first invocation and honor the second one, taking advantage of a
2967 richer context. */
2970 /* Reporting an constructor invocation error. */
2971 static void
2972 parse_ctor_invocation_error ()
2973 {
2976 else
2978 }
2980 /* Reporting JDK1.1 features not implemented. */
2982 static tree
2985 {
2987 java_error_count++;
2988 return empty_stmt_node;
2989 }
2993 void
2996 {
3005 return;
3007 /* Save current error location but report latter, when the context is
3008 richer. */
3010 {
3013 /* Do something to use the previous line if we're reaching the
3014 end of the file... */
3015 #ifdef VERBOSE_SKELETON
3017 #endif
3018 return;
3019 }
3021 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3023 return;
3027 java_warning_count++;
3028 else
3029 java_error_count++;
3032 {
3035 }
3047 else
3050 /* This allow us to cheaply avoid an extra 'Invalid expression
3051 statement' error report when errors have been already reported on
3052 the same line. This occurs when we report an error but don't have
3053 a synchronization point other than ';', which
3054 expression_statement is the only one to take care of. */
3056 }
3058 static void
3060 tree cl;
3063 {
3073 /* We have a CL, that's a good reason for using it if it contains data */
3084 }
3086 /* Issue an error message at a current source line CL */
3088 void
3090 {
3096 }
3098 /* Issue a warning at a current source line CL */
3100 static void
3102 {
3111 }
3113 static tree
3115 tree node;
3116 {
3118 {
3120 tree to_return;
3123 {
3124 case BLOCK:
3126 continue;
3128 case COMPOUND_EXPR:
3131 return to_return;
3133 continue;
3135 case LOOP_EXPR:
3137 continue;
3139 case LABELED_BLOCK_EXPR:
3141 continue;
3143 default:
3147 return node;
3148 return NULL_TREE;
3149 }
3150 }
3151 return NULL_TREE;
3152 }
3154 /* Issue a missing return statement error. Uses METHOD to figure the
3155 last line of the method the error occurs in. */
3157 static void
3159 tree method;
3160 {
3163 }
3165 /* Issue an unreachable statement error. From NODE, find the next
3166 statement to report appropriately. */
3167 static void
3169 tree node;
3170 {
3171 /* Browse node to find the next expression node that has a WFL. Use
3172 the location to report the error */
3175 else
3179 {
3182 }
3183 else
3184 abort ();
3185 }
3187 int
3188 java_report_errors ()
3189 {
3198 return java_error_count;
3199 }
3204 {
3206 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3208 /* Access modifier looked-up first for easier report on forbidden
3209 access. */
3223 return buffer;
3224 #undef COPY_RETURN
3225 }
3227 /* Issuing error messages upon redefinition of classes, interfaces or
3228 variables. */
3230 static void
3234 {
3238 /* Here we should point out where its redefined. It's a unicode. FIXME */
3239 }
3241 static void
3245 {
3248 /* Figure a proper name for type. We might haven't resolved it */
3251 else
3258 }
3260 /* If ANAME is terminated with `[]', it indicates an array. This
3261 function returns the number of `[]' found and if this number is
3262 greater than zero, it extracts the array type name and places it in
3263 the node pointed to by TRIMMED unless TRIMMED is null. */
3265 static int
3267 tree aname;
3269 {
3279 return array_dims;
3280 }
3282 static tree
3285 {
3288 /* Eventually get more dims */
3291 /* If we have, then craft a new type for this variable */
3293 {
3296 /* If we have a pointer, use its type */
3300 /* Building the first dimension of a primitive type uses this
3301 function */
3303 {
3305 more_dims--;
3306 }
3307 /* Otherwise, if we have a WFL for this type, use it (the type
3308 is already an array on an unresolved type, and we just keep
3309 on adding dimensions) */
3311 {
3314 NULL);
3315 }
3317 /* Add all the dimensions */
3321 /* The type may have been incomplete in the first place */
3324 }
3328 return type;
3329 }
3331 /* Build something that the type identifier resolver will identify as
3332 being an array to an unresolved type. TYPE_WFL is a WFL on a
3333 identifier. */
3335 static tree
3337 tree type_or_wfl;
3338 {
3340 tree wfl;
3342 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3343 just create a array type */
3356 /* Re-install the existing qualifications so that the type can be
3357 resolved properly. */
3359 return wfl;
3360 }
3362 static void
3365 {
3369 }
3371 /* Bulk of common class/interface checks. Return 1 if an error was
3372 encountered. TAG is 0 for a class, 1 for an interface. */
3374 static int
3378 {
3379 tree node;
3390 /* Scope of an interface/class type name:
3391 - Can't be imported by a single type import
3392 - Can't already exists in the package */
3396 {
3397 parse_error_context
3402 }
3404 {
3408 }
3413 /* If public, file name should match class/interface name, except
3414 when dealing with an inner class */
3416 {
3419 /* Contains OS dependent assumption on path separator. FIXME */
3422 f--)
3423 ;
3425 f++;
3429 parse_error_context
3434 }
3436 /* Static classes can be declared only in top level classes. Note:
3437 once static, a inner class is a top level class. */
3439 {
3440 /* Catch the specific error of declaring an class inner class
3441 with no toplevel enclosing class. Prevent check_modifiers from
3442 complaining a second time */
3444 {
3445 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3448 }
3449 /* Else, in the context of a top-level class declaration, let
3450 `check_modifiers' do its job, otherwise, give it a go */
3451 else
3453 }
3455 /* Inner classes can be declared private or protected
3456 within their enclosing classes. */
3458 {
3459 /* A class which is local to a block can't be public, private,
3460 protected or static. But it is created final, so allow this
3461 one. */
3464 else
3465 {
3470 }
3471 }
3474 {
3477 else
3482 }
3483 else
3484 check_modifiers ((current_function_decl ?
3489 }
3491 static void
3493 tree cpc_list;
3494 {
3495 tree name;
3498 return;
3499 else
3502 /* Pick the qualified name when dealing with the first upmost
3503 enclosing class */
3508 /* Why is NO_DOLLAR_IN_LABEL defined? */
3509 #if 0
3510 #ifdef NO_DOLLAR_IN_LABEL
3512 #endif
3513 #endif
3515 }
3517 /* Can't redefine a class already defined in an earlier scope. */
3519 static int
3522 {
3523 tree scope_list;
3528 {
3529 parse_error_context
3530 (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3533 }
3535 }
3537 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3538 we remember ENCLOSING and SUPER. */
3540 static tree
3544 {
3549 {
3556 return decl;
3559 /* Explore enclosing contexts. */
3561 {
3564 return decl;
3565 }
3567 /* Now go to the upper classes, bail out if necessary. We will
3568 analyze the returned SUPER and act accordingly (see
3569 do_resolve_class.) */
3572 break;
3576 else
3579 /* We may not have checked for circular inheritance yet, so do so
3580 here to prevent an infinite loop. */
3583 {
3587 parse_error_context
3591 }
3592 else
3594 }
3596 /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3600 return NULL_TREE;
3601 }
3603 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3604 qualified. */
3606 static tree
3609 {
3612 return NULL_TREE;
3616 /* First search: within the scope of `enclosing', search for name */
3621 else
3625 return to_return;
3627 /* We're dealing with a qualified name. Try to resolve thing until
3628 we get something that is an enclosing class. */
3630 {
3635 {
3640 /* Don't try to resolve ACC as a class name if it follows
3641 the current package name. We don't want to pick something
3642 that's accidentally there: for example `a.b.c' in package
3643 `a.b' shouldn't trigger loading `a' if it's there by
3644 itself. */
3649 else
3651 }
3653 /* A NULL qual and a decl means that the search ended
3654 successfully?!? We have to do something then. FIXME */
3658 else
3660 }
3661 /* Otherwise, create a qual for the other part of the resolution. */
3662 else
3666 }
3668 /* We go inside the list of sub classes and try to find a way
3669 through. */
3671 static tree
3674 {
3676 return NULL_TREE;
3679 {
3682 tree inner_list;
3686 {
3688 {
3690 break;
3691 }
3692 }
3694 }
3697 }
3699 /* Reach all inner classes and tie their unqualified name to a
3700 DECL. */
3702 static void
3704 tree outer;
3706 {
3707 tree l;
3712 }
3714 static void
3715 link_nested_class_to_enclosing ()
3716 {
3718 {
3724 }
3725 }
3727 static tree
3729 tree name;
3730 {
3734 {
3742 }
3743 return id;
3744 }
3746 /* If DECL is NULL, create and push a new DECL, record the current
3747 line CL and do other maintenance things. */
3749 static tree
3752 {
3756 /* Take care of the file and line business */
3758 /* If we're emiting xrefs, store the line/col number information */
3761 else
3771 /* Link the declaration to the already seen ones */
3775 /* Create a new nodes in the global lists */
3779 /* Install a new dependency list element */
3784 return decl;
3785 }
3787 static void
3790 {
3791 tree node;
3792 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3793 takes care of ensuring that:
3794 - This is an accessible interface type,
3795 - Circularity detection.
3796 parser_add_interface is then called. If present but not defined,
3797 the check operation is delayed until the super interface gets
3798 defined. */
3800 {
3804 {
3807 }
3808 else
3811 }
3812 }
3814 /* Create an interface in pass1 and return its decl. Return the
3815 interface's decl in pass 2. */
3817 static tree
3821 {
3826 /* Certain syntax errors are making SUPER be like ID. Avoid this
3827 case. */
3833 /* Basic checks: scope, redefinition, modifiers */
3835 {
3836 PUSH_ERROR ();
3837 return NULL_TREE;
3838 }
3840 /* Suspend the current parsing context if we're parsing an inner
3841 interface */
3843 {
3844 java_parser_context_suspend ();
3845 /* Interface members are public. */
3848 }
3850 /* Push a new context for (static) initialized upon declaration fields */
3851 java_parser_context_push_initialized_field ();
3853 /* Interface modifiers check
3854 - public/abstract allowed (already done at that point)
3855 - abstract is obsolete (comes first, it's a warning, or should be)
3856 - Can't use twice the same (checked in the modifier rule) */
3858 parse_warning_context
3860 "Redundant use of `abstract' modifier. Interface `%s' is implicitely abstract", IDENTIFIER_POINTER (raw_name));
3862 /* Create a new decl if DECL is NULL, otherwise fix it */
3865 /* Set super info and mark the class a complete */
3872 return decl;
3873 }
3875 /* Anonymous class counter. Will be reset to 1 every time a non
3876 anonymous class gets created. */
3879 /* Patch anonymous class CLASS, by either extending or implementing
3880 DEP. */
3882 static void
3885 {
3890 /* If it's an interface, implement it */
3892 {
3893 tree s_binfo;
3897 return;
3903 /* And add the interface */
3905 }
3906 /* Otherwise, it's a type we want to extend */
3907 else
3908 {
3910 return;
3912 }
3913 }
3915 static tree
3918 tree type_name;
3919 {
3924 /* The unqualified name of the anonymous class. It's just a number. */
3929 /* We know about the type to extend/implement. We go ahead */
3931 {
3932 /* Create a class which either implements on extends the designated
3933 class. The class bears an innacessible name. */
3935 {
3936 /* It's OK to modify it here. It's been already used and
3937 shouldn't be reused */
3939 /* Interfaces should presented as a list of WFLs */
3941 }
3942 else
3944 }
3948 /* We didn't know anything about the stuff. We register a dependence. */
3953 return class;
3954 }
3956 /* Create a class in pass1 and return its decl. Return class
3957 interface's decl in pass 2. */
3959 static tree
3963 {
3966 tree super_decl_type;
3968 /* Certain syntax errors are making SUPER be like ID. Avoid this
3969 case. */
3977 /* Basic check: scope, redefinition, modifiers */
3979 {
3980 PUSH_ERROR ();
3981 return NULL_TREE;
3982 }
3984 /* Suspend the current parsing context if we're parsing an inner
3985 class or an anonymous class. */
3987 {
3988 java_parser_context_suspend ();
3989 /* Interface members are public. */
3992 }
3994 /* Push a new context for (static) initialized upon declaration fields */
3995 java_parser_context_push_initialized_field ();
3997 /* Class modifier check:
3998 - Allowed modifier (already done at that point)
3999 - abstract AND final forbidden
4000 - Public classes defined in the correct file */
4002 parse_error_context
4006 /* Create a new decl if DECL is NULL, otherwise fix it */
4009 /* If SUPER exists, use it, otherwise use Object */
4011 {
4012 /* Can't extend java.lang.Object */
4014 {
4016 return NULL_TREE;
4017 }
4019 super_decl_type =
4021 }
4024 /* We're defining java.lang.Object */
4025 else
4028 /* A class nested in an interface is implicitly static. */
4031 {
4033 }
4035 /* Set super info and mark the class as complete. */
4042 /* Add the private this$<n> field, Replicate final locals still in
4043 scope as private final fields mangled like val$<local_name>.
4044 This doesn't not occur for top level (static) inner classes. */
4048 /* If doing xref, store the location at which the inherited class
4049 (if any) was seen. */
4053 /* Eventually sets the @deprecated tag flag */
4056 /* Reset the anonymous class counter when declaring non inner classes */
4060 return decl;
4061 }
4063 /* End a class declaration: register the statements used to create
4064 finit$ and <clinit>, pop the current class and resume the prior
4065 parser context if necessary. */
4067 static void
4070 {
4071 /* If an error occured, context weren't pushed and won't need to be
4072 popped by a resume. */
4075 java_parser_context_pop_initialized_field ();
4076 POP_CPC ();
4078 java_parser_context_resume ();
4080 /* We're ending a class declaration, this is a good time to reset
4081 the interface cout. Note that might have been already done in
4082 create_interface, but if at that time an inner class was being
4083 dealt with, the interface count was reset in a context created
4084 for the sake of handling inner classes declaration. */
4086 }
4088 static void
4090 tree class_decl;
4091 tree fct_decl;
4092 {
4098 ACC_PRIVATE);
4102 return;
4106 {
4107 tree decl;
4109 {
4113 /* Avoid non final arguments. */
4115 continue;
4121 /* Build an initialization for the field: it will be
4122 initialized by a parameter added to finit$, bearing a
4123 mangled name of the field itself (param$<n>.) The
4124 parameter is provided to finit$ by the constructor
4125 invoking it (hence the constructor will also feature a
4126 hidden parameter, set to the value of the outer context
4127 local at the time the inner class is created.)
4129 Note: we take into account all possible locals that can
4130 be accessed by the inner class. It's actually not trivial
4131 to minimize these aliases down to the ones really
4132 used. One way to do that would be to expand all regular
4133 methods first, then finit$ to get a picture of what's
4134 used. It works with the exception that we would have to
4135 go back on all constructor invoked in regular methods to
4136 have their invokation reworked (to include the right amount
4137 of alias initializer parameters.)
4139 The only real way around, I think, is a first pass to
4140 identify locals really used in the inner class. We leave
4141 the flag FIELD_LOCAL_ALIAS_USED around for that future
4142 use.
4144 On the other hand, it only affect local inner classes,
4145 whose constructors (and finit$ call) will be featuring
4146 unecessary arguments. It's easy for a developper to keep
4147 this number of parameter down by using the `final'
4148 keyword only when necessary. For the time being, we can
4149 issue a warning on unecessary finals. FIXME */
4153 /* Register the field. The TREE_LIST holding the part
4154 initialized/initializer will be marked ARG_FINAL_P so
4155 that the created field can be marked
4156 FIELD_LOCAL_ALIAS. */
4160 }
4161 }
4164 return;
4166 /* If we ever registered an alias field, insert and marker to
4167 remeber where the list ends. The second part of the list (the one
4168 featuring initialized fields) so it can be later reversed to
4169 enforce 8.5. The marker will be removed during that operation. */
4173 }
4175 /* Can't use lookup_field () since we don't want to load the class and
4176 can't set the CLASS_LOADED_P flag */
4178 static tree
4180 tree class;
4181 tree name;
4182 {
4183 tree decl;
4185 {
4187 return decl;
4188 }
4189 return NULL_TREE;
4190 }
4192 /* Wrap around lookup_field that doesn't potentially upset the value
4193 of CLASS */
4195 static tree
4198 {
4201 java_parser_context_save_global ();
4203 /* Last chance: if we're within the context of an inner class, we
4204 might be trying to access a local variable defined in an outer
4205 context. We try to look for it now. */
4207 {
4208 tree new_name;
4213 }
4215 {
4218 }
4220 java_parser_context_restore_global ();
4222 }
4224 /* Find duplicate field within the same class declarations and report
4225 the error. Returns 1 if a duplicated field was found, 0
4226 otherwise. */
4228 static int
4231 {
4232 /* This might be modified to work with method decl as well */
4235 {
4241 /* The type may not have been completed by the time we report
4242 the error */
4248 parse_error_context
4256 }
4258 }
4260 /* Field registration routine. If TYPE doesn't exist, field
4261 declarations are linked to the undefined TYPE dependency list, to
4262 be later resolved in java_complete_class () */
4264 static void
4268 {
4279 return;
4281 /* If we're adding fields to interfaces, those fields are public,
4282 static, final */
4284 {
4292 INTERFACE_FIELD_MODIFIERS);
4294 }
4296 /* Obtain a suitable type for resolution, if necessary */
4299 /* If TYPE is fully resolved and we don't have a reference, make one */
4304 {
4305 tree real_type;
4306 tree field_decl;
4311 /* Can't declare non-final static fields in inner classes */
4314 parse_error_context
4319 /* Process NAME, as it may specify extra dimension(s) for it */
4322 /* Type adjustment. We may have just readjusted TYPE because
4323 the variable specified more dimensions. Make sure we have
4324 a reference if we can and don't have one already. Also
4325 change the name if we have an init. */
4327 {
4331 }
4334 /* Check for redeclarations */
4336 continue;
4338 /* Set lineno to the line the field was found and create a
4339 declaration for it. Eventually sets the @deprecated tag flag. */
4342 else
4347 /* If the field denotes a final instance variable, then we
4348 allocate a LANG_DECL_SPECIFIC part to keep track of its
4349 initialization. We also mark whether the field was
4350 initialized upon it's declaration. We don't do that if the
4351 created field is an alias to a final local. */
4353 {
4358 }
4360 /* If the couple initializer/initialized is marked ARG_FINAL_P,
4361 we mark the created field FIELD_LOCAL_ALIAS, so that we can
4362 hide parameters to this inner class finit$ and
4363 constructors. It also means that the field isn't final per
4364 say. */
4366 {
4369 }
4371 /* Check if we must chain. */
4375 /* If we have an initialization value tied to the field */
4377 {
4378 /* The field is declared static */
4380 {
4381 /* We include the field and its initialization part into
4382 a list used to generate <clinit>. After <clinit> is
4383 walked, field initializations will be processed and
4384 fields initialized with known constants will be taken
4385 out of <clinit> and have their DECL_INITIAL set
4386 appropriately. */
4392 }
4393 /* A non-static field declared with an immediate initialization is
4394 to be initialized in <init>, if any. This field is remembered
4395 to be processed at the time of the generation of <init>. */
4396 else
4397 {
4400 }
4403 }
4404 }
4406 }
4408 /* Generate finit$, using the list of initialized fields to populate
4409 its body. finit$'s parameter(s) list is adjusted to include the
4410 one(s) used to initialized the field(s) caching outer context
4411 local(s). */
4413 static tree
4415 tree class_type;
4416 {
4436 current));
4438 return mdecl;
4439 }
4441 /* Generate a function to run the instance initialization code. The
4442 private method is called `instinit$'. Unless we're dealing with an
4443 anonymous class, we determine whether all ctors of CLASS_TYPE
4444 declare a checked exception in their `throws' clause in order to
4445 see whether it's necessary to encapsulate the instance initializer
4446 statements in a try/catch/rethrow sequence. */
4448 static tree
4450 tree class_type;
4451 {
4452 tree current;
4457 void_type_node,
4463 /* Gather all the statements in a compound */
4468 /* We need to encapsulate COMPOUND by a try/catch statement to
4469 rethrow exceptions that might occur in the instance initializer.
4470 We do that only if all ctors of CLASS_TYPE are set to catch a
4471 checked exception. This doesn't apply to anonymous classes (since
4472 they don't have declared ctors.) */
4475 {
4480 exception_type_node);
4481 }
4487 return mdecl;
4488 }
4490 /* FIXME */
4491 static tree
4493 tree class_type;
4494 {
4498 {
4501 to_return =
4503 parm);
4504 }
4505 return to_return;
4506 }
4508 /* Shared accros method_declarator and method_header to remember the
4509 patch stage that was reached during the declaration of the method.
4510 A method DECL is built differently is there is no patch
4511 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4512 pending on the currently defined method. */
4516 /* Check the method declaration and add the method to its current
4517 class. If the argument list is known to contain incomplete types,
4518 the method is partially added and the registration will be resume
4519 once the method arguments resolved. If TYPE is NULL, we're dealing
4520 with a constructor. */
4522 static tree
4526 {
4536 return error_mark_node;
4546 return NULL_TREE;
4548 /* There are some forbidden modifiers for an abstract method and its
4549 class must be abstract as well. */
4551 {
4559 parse_error_context
4563 }
4565 /* Things to be checked when declaring a constructor */
4567 {
4569 /* 8.6: Constructor declarations: we might be trying to define a
4570 method without specifying a return type. */
4572 parse_error_context
4574 /* 8.6.3: Constructor modifiers */
4575 else
4576 {
4582 }
4583 /* If we found error here, we don't consider it's OK to tread
4584 the method definition as a constructor, for the rest of this
4585 function */
4588 }
4590 /* Method declared within the scope of an interface are implicitly
4591 abstract and public. Conflicts with other erroneously provided
4592 modifiers are checked right after. */
4595 {
4596 /* If FLAGS isn't set because of a modifier, turn the
4597 corresponding modifier WFL to NULL so we issue a warning on
4598 the obsolete use of the modifier */
4605 }
4607 /* Inner class can't declare static methods */
4609 {
4610 parse_error_context
4611 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4614 }
4616 /* Modifiers context reset moved up, so abstract method declaration
4617 modifiers can be later checked. */
4619 /* Set constructor returned type to void and method name to <init>,
4620 unless we found an error identifier the constructor (in which
4621 case we retain the original name) */
4623 {
4627 }
4628 else
4631 /* Do the returned type resolution and registration if necessary */
4640 {
4644 }
4645 else
4649 /* When defining an abstract or interface method, the curly
4650 bracket at level 1 doesn't exist because there is no function
4651 body */
4655 /* Remember the original argument list */
4659 {
4662 /* Patch for the return type */
4664 {
4667 }
4668 /* This is the stop JDEP. METH allows the function's signature
4669 to be computed. */
4671 }
4672 else
4676 /* Remember final parameters */
4679 /* Fix the method argument list so we have the argument name
4680 information */
4683 /* Register the parameter number and re-install the current line
4684 number */
4688 /* Register exception specified by the `throws' keyword for
4689 resolution and set the method decl appropriate field to the list.
4690 Note: the grammar ensures that what we get here are class
4691 types. */
4693 {
4696 {
4701 }
4703 }
4708 /* Set the flag if we correctly processed a constructor */
4710 {
4712 /* Compute and store the number of artificial parameters declared
4713 for this constructor */
4717 count++;
4719 }
4721 /* Eventually set the @deprecated tag flag */
4724 /* If doing xref, store column and line number information instead
4725 of the line number only. */
4729 return meth;
4730 }
4732 static void
4735 {
4738 {
4741 }
4743 {
4747 }
4748 }
4750 /* Complete the method declaration with METHOD_BODY. */
4752 static void
4754 tree method_body;
4755 {
4759 return;
4763 /* 8.4.5 Method Body */
4765 {
4773 }
4775 {
4777 parse_error_context
4782 }
4791 maybe_absorb_scoping_blocks ();
4792 /* Exit function's body */
4793 exit_block ();
4794 /* Merge last line of the function with first line, directly in the
4795 function decl. It will be used to emit correct debug info. */
4799 /* Since function's argument's list are shared, reset the
4800 ARG_FINAL_P parameter that might have been set on some of this
4801 function parameters. */
4804 /* So we don't have an irrelevant function declaration context for
4805 the next static block we'll see. */
4807 }
4809 /* Build a an error message for constructor circularity errors. */
4814 {
4820 }
4822 /* Verify a circular call to METH. Return 1 if an error is found, 0
4823 otherwise. */
4825 static int
4828 {
4831 tree c;
4833 /* If we haven't already registered LIST with the garbage collector,
4834 do so now. */
4836 {
4839 }
4842 {
4844 {
4847 {
4848 tree liste;
4851 {
4852 parse_error_context
4854 constructor_circularity_msg
4856 java_error_count--;
4857 }
4858 }
4866 }
4867 }
4869 {
4874 }
4876 }
4878 /* Check modifiers that can be declared but exclusively */
4880 static void
4883 {
4891 parse_error_context
4892 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4901 }
4903 /* Check the methode header METH for abstract specifics features */
4905 static void
4907 tree meth;
4908 {
4920 }
4922 /* Create a FUNCTION_TYPE node and start augmenting it with the
4923 declared function arguments. Arguments type that can't be resolved
4924 are left as they are, but the returned node is marked as containing
4925 incomplete types. */
4927 static tree
4930 {
4938 return error_mark_node;
4940 /* If we're dealing with an inner class constructor, we hide the
4941 this$<n> decl in the name field of its parameter declaration. We
4942 also might have to hide the outer context local alias
4943 initializers. Not done when the class is a toplevel class. */
4946 {
4948 /* First the aliases, linked to the regular parameters */
4949 aliases_list =
4955 /* Then this$<n> */
4959 list);
4960 }
4963 {
4970 tree real_type;
4972 /* Obtain a suitable type for resolution, if necessary */
4975 /* Process NAME, as it may specify extra dimension(s) for it */
4981 {
4985 }
4987 /* Check redefinition */
4990 {
4991 parse_error_context
4995 break;
4996 }
4998 /* If we've an incomplete argument type, we know there is a location
4999 to patch when the type get resolved, later. */
5002 {
5008 }
5010 /* The argument node: a name and a (possibly) incomplete type. */
5012 /* Remeber arguments declared final. */
5019 }
5022 return node;
5023 }
5025 static int
5027 tree wfl;
5030 {
5032 {
5034 {
5040 else
5042 }
5044 }
5048 }
5050 /* From NAME, build a qualified identifier node using the
5051 qualification from the current package definition. */
5053 static tree
5055 tree name;
5056 {
5057 tree nested_class_name;
5060 return nested_class_name;
5064 else
5065 return name;
5066 }
5068 /* Called once the type a interface extends is resolved. Returns 0 if
5069 everything is OK. */
5071 static int
5074 {
5077 /* Has to be an interface */
5079 {
5080 parse_error_context
5088 }
5090 /* Check top-level interface access. Inner classes are subject to member
5091 access rules (6.6.1). */
5100 }
5102 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5103 0 if everthing is OK. */
5105 static int
5108 {
5111 /* SUPER should be a CLASS (neither an array nor an interface) */
5113 {
5114 parse_error_context
5120 }
5123 {
5127 }
5129 /* Check top-level class scope. Inner classes are subject to member access
5130 rules (6.6.1). */
5139 }
5141 /* Create a new dependency list and link it (in a LIFO manner) to the
5142 CTXP list of type dependency list. */
5144 static void
5147 {
5152 }
5157 {
5160 {
5164 }
5165 return prev;
5166 }
5168 /* Create a fake pointer based on the ID stored in
5169 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5170 registered again. */
5172 static tree
5174 tree type_name;
5175 {
5182 else
5183 abort ();
5188 return ptr;
5189 }
5191 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5192 non NULL instead of computing a new fake type based on WFL. The new
5193 dependency is inserted in the current type dependency list, in FIFO
5194 manner. */
5196 static tree
5200 {
5212 /* For some dependencies, set the enclosing class of the current
5213 class to be the enclosing context */
5218 else
5224 return ptr;
5225 }
5227 /* This checks for circular references with innerclasses. We start
5228 from SOURCE and should never reach TARGET. Extended/implemented
5229 types in SOURCE have their enclosing context checked not to reach
5230 TARGET. When the last enclosing context of SOURCE is reached, its
5231 extended/implemented types are also checked not to reach TARGET.
5232 In case of error, WFL of the offending type is returned; NULL_TREE
5233 otherwise. */
5235 static tree
5237 tree source;
5238 tree target;
5239 {
5245 return NULL_TREE;
5248 {
5255 {
5256 /* An enclosing context shouldn't be TARGET */
5260 /* When we reach the enclosing last context, start a check
5261 on it, with the same target */
5264 return cl;
5265 }
5266 }
5267 return NULL_TREE;
5268 }
5270 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5271 offending type if a circularity is detected. NULL_TREE is returned
5272 otherwise. TYPE can be an interface or a class. */
5274 static tree
5276 tree type;
5277 {
5282 return NULL_TREE;
5285 {
5288 return NULL_TREE;
5289 }
5292 {
5297 }
5298 return NULL_TREE;
5299 }
5301 void
5302 java_check_circular_reference ()
5303 {
5304 tree current;
5306 {
5308 tree cl;
5315 (cyclic_inheritance_report ?
5317 }
5318 }
5320 /* Augment the parameter list PARM with parameters crafted to
5321 initialize outer context locals aliases. Through ARTIFICIAL, a
5322 count is kept of the number of crafted parameters. MODE governs
5323 what eventually gets created: something suitable for a function
5324 creation or a function invocation, either the constructor or
5325 finit$. */
5327 static tree
5332 {
5333 tree field;
5338 {
5341 tree mangled_id;
5344 {
5345 case AIPL_FUNCTION_DECLARATION:
5351 else
5353 break;
5355 case AIPL_FUNCTION_CREATION:
5359 break;
5361 case AIPL_FUNCTION_FINIT_INVOCATION:
5364 /* Now, this is wrong. purpose should always be the NAME
5365 of something and value its matching value (decl, type,
5366 etc...) FIXME -- but there is a lot to fix. */
5368 /* When invoked for this kind of operation, we already
5369 know whether a field is used or not. */
5372 break;
5374 case AIPL_FUNCTION_CTOR_INVOCATION:
5375 /* There are two case: the constructor invokation happends
5376 outside the local inner, in which case, locales from the outer
5377 context are directly used.
5379 Otherwise, we fold to using the alias directly. */
5382 else
5383 {
5386 }
5387 break;
5388 }
5392 }
5394 {
5399 }
5401 return parm;
5402 }
5404 /* Craft a constructor for CLASS_DECL -- what we should do when none
5405 where found. ARGS is non NULL when a special signature must be
5406 enforced. This is the case for anonymous classes. */
5408 static void
5411 {
5420 /* The constructor name is <init> unless we're dealing with an
5421 anonymous class, in which case the name will be fixed after having
5422 be expanded. */
5425 else
5428 /* If we're dealing with an inner class constructor, we hide the
5429 this$<n> decl in the name field of its parameter declaration. */
5431 {
5436 /* Some more arguments to be hidden here. The values of the local
5437 variables of the outer context that the inner class needs to see. */
5441 }
5443 /* Then if there are any args to be enforced, enforce them now */
5445 {
5448 }
5454 /* Now, mark the artificial parameters. */
5457 }
5460 /* Fix the constructors. This will be called right after circular
5461 references have been checked. It is necessary to fix constructors
5462 early even if no code generation will take place for that class:
5463 some generated constructor might be required by the class whose
5464 compilation triggered this one to be simply loaded. */
5466 void
5467 java_fix_constructors ()
5468 {
5469 tree current;
5472 {
5475 tree decl;
5478 continue;
5482 {
5484 {
5487 }
5488 }
5490 /* Anonymous class constructor can't be generated that early. */
5493 }
5494 }
5496 /* safe_layout_class just makes sure that we can load a class without
5497 disrupting the current_class, input_file, lineno, etc, information
5498 about the class processed currently. */
5500 void
5502 tree class;
5503 {
5513 }
5515 static tree
5518 {
5519 tree decl;
5523 else
5524 {
5528 }
5533 {
5536 {
5540 }
5542 }
5543 return decl;
5544 }
5546 /* Complete unsatisfied class declaration and their dependencies */
5548 void
5549 java_complete_class ()
5550 {
5551 tree cclass;
5554 tree type;
5556 /* Process imports */
5557 process_imports ();
5559 /* Rever things so we have the right order */
5566 {
5569 /* We keep the compilation unit imports in the class so that
5570 they can be used later to resolve type dependencies that
5571 aren't necessary to solve now. */
5576 {
5577 tree decl;
5579 continue;
5581 /* Now it's time to patch */
5583 {
5584 case JDEP_SUPER:
5585 /* Simply patch super */
5587 continue;
5590 break;
5592 case JDEP_FIELD:
5593 {
5594 /* We do part of the job done in add_field */
5603 SOURCE_FRONTEND_DEBUG
5607 break;
5608 }
5610 case JDEP_METHOD_RETURN:
5613 {
5615 {
5620 SOURCE_FRONTEND_DEBUG
5624 IDENTIFIER_POINTER (EXPR_WFL_NODE
5627 }
5628 else
5632 break;
5633 else
5635 }
5637 {
5639 /* Recompute and reset the signature, check first that
5640 all types are now defined. If they're not,
5641 dont build the signature. */
5643 {
5646 }
5647 }
5648 else
5649 continue;
5650 break;
5652 case JDEP_INTERFACE:
5655 continue;
5657 break;
5659 case JDEP_PARM:
5660 case JDEP_VARIABLE:
5665 break;
5667 case JDEP_TYPE:
5669 SOURCE_FRONTEND_DEBUG
5672 break;
5674 case JDEP_EXCEPTION:
5676 SOURCE_FRONTEND_DEBUG
5679 break;
5681 case JDEP_ANONYMOUS:
5683 break;
5685 default:
5686 abort ();
5687 }
5688 }
5689 }
5690 return;
5691 }
5693 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5694 array. */
5696 static tree
5699 {
5703 tree resolved_type_decl;
5706 {
5710 {
5713 resolved_type);
5714 }
5715 return resolved_type_decl;
5716 }
5718 /* 1- Check to see if we have an array. If true, find what we really
5719 want to resolve */
5724 /* 2- Resolve the bare type */
5727 return NULL_TREE;
5730 /* 3- If we have and array, reconstruct the array down to its nesting */
5732 {
5736 }
5738 return resolved_type_decl;
5739 }
5741 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5742 are used to report error messages. Do not try to replace TYPE_NAME
5743 (class_type) by a variable, since it is changed by
5744 find_in_imports{_on_demand} and (but it doesn't really matter)
5745 qualify_and_find. */
5747 tree
5750 {
5755 /* This hash table is used to register the classes we're going
5756 through when searching the current class as an inner class, in
5757 order to detect circular references. Remember to free it before
5758 returning the section 0- of this function. */
5762 /* 0- Search in the current class as an inner class.
5763 Maybe some code here should be added to load the class or
5764 something, at least if the class isn't an inner class and ended
5765 being loaded from class file. FIXME. */
5767 {
5771 break;
5773 /* If we haven't found anything because SUPER reached Object and
5774 ENCLOSING happens to be an innerclass, try the enclosing context. */
5778 else
5780 }
5785 return new_class_decl;
5787 /* 1- Check for the type in single imports. This will change
5788 TYPE_NAME() if something relevant is found */
5791 /* 2- And check for the type in the current compilation unit */
5793 {
5798 }
5800 /* 3- Search according to the current package definition */
5802 {
5805 return new_class_decl;
5806 }
5808 /* 4- Check the import on demands. Don't allow bar.baz to be
5809 imported from foo.* */
5812 return NULL_TREE;
5814 /* If found in find_in_imports_on_demant, the type has already been
5815 loaded. */
5817 return new_class_decl;
5819 /* 5- Try with a name qualified with the package name we've seen so far */
5821 {
5822 tree package;
5824 /* If there is a current package (ctxp->package), it's the first
5825 element of package_list and we can skip it. */
5832 return new_class_decl;
5833 }
5835 /* 5- Check an other compilation unit that bears the name of type */
5841 /* If we don't have a value for CL, then we're being called recursively.
5842 We can't check package access just yet, but it will be taken care of
5843 by the caller. */
5845 {
5847 return NULL_TREE;
5848 }
5850 /* 6- Last call for a resolution */
5852 }
5854 static tree
5857 {
5859 tree new_class_decl;
5864 {
5870 }
5871 return NULL_TREE;
5872 }
5874 /* Resolve NAME and lay it out (if not done and if not the current
5875 parsed class). Return a decl node. This function is meant to be
5876 called when type resolution is necessary during the walk pass. */
5878 static tree
5880 tree something;
5881 tree cl;
5882 {
5885 /* Don't do that on the current class */
5889 /* Don't do anything for void and other primitive types */
5891 return NULL_TREE;
5893 /* Pointer types can be reall pointer types or fake pointers. When
5894 finding a real pointer, recheck for primitive types */
5896 {
5898 {
5901 return NULL_TREE;
5902 }
5903 else
5905 }
5907 /* Don't do anything for arrays of primitive types */
5910 return NULL_TREE;
5912 /* Something might be a WFL */
5916 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5917 TYPE_DECL or a real TYPE */
5923 return NULL_TREE;
5925 /* Resolve and layout if necessary */
5928 /* Check methods */
5931 /* Layout the type if necessary */
5935 return decl;
5936 }
5938 /* Resolve a class, returns its decl but doesn't perform any
5939 layout. The current parsing context is saved and restored */
5941 static tree
5944 {
5947 java_parser_context_save_global ();
5949 java_parser_context_restore_global ();
5951 return decl;
5952 }
5954 /* Called when reporting errors. Skip the '[]'s in a complex array
5955 type description that failed to be resolved. purify_type_name can't
5956 use an identifier tree. */
5961 {
5967 {
5970 return stripped_name;
5971 }
5972 return name;
5973 }
5975 /* The type CURRENT refers to can't be found. We print error messages. */
5977 static void
5980 {
5984 return;
5988 {
5989 case JDEP_SUPER:
5990 parse_error_context
5994 break;
5995 case JDEP_FIELD:
5996 parse_error_context
6000 break;
6002 parse_error_context
6007 break;
6009 parse_error_context
6013 break;
6014 case JDEP_INTERFACE:
6015 parse_error_context
6020 break;
6021 case JDEP_VARIABLE:
6022 parse_error_context
6024 purify_type_name (IDENTIFIER_POINTER
6027 break;
6029 parse_error_context
6032 break;
6033 default:
6034 /* Fix for -Wall. Just break doing nothing. The error will be
6035 caught later */
6036 break;
6037 }
6038 }
6040 /* Return a static string containing the DECL prototype string. If
6041 DECL is a constructor, use the class name instead of the form
6042 <init> */
6046 tree decl;
6047 {
6052 {
6055 }
6061 return to_return;
6062 }
6064 /* Track method being redefined inside the same class. As a side
6065 effect, set DECL_NAME to an IDENTIFIER (prior entering this
6066 function it's a FWL, so we can track errors more accurately.) */
6068 static int
6071 {
6074 /* There's no need to verify <clinit> and finit$ and instinit$ */
6081 {
6083 break;
6087 {
6088 parse_error_context
6093 }
6094 }
6096 }
6098 /* Return 1 if check went ok, 0 otherwise. */
6099 static int
6103 {
6110 {
6116 continue;
6118 /* Now verify that somewhere in between TYPE and CLASS,
6119 abstract method METHOD gets a non abstract definition
6120 that is inherited by CLASS. */
6128 do {
6132 /* Method search */
6135 {
6146 {
6148 break;
6149 }
6150 }
6154 /* Report that abstract METHOD didn't find an implementation
6155 that CLASS can use. */
6157 {
6162 parse_error_context
6164 "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
6174 }
6175 }
6178 {
6179 /* Check for implemented interfaces. */
6183 {
6186 }
6187 }
6189 return ok;
6190 }
6192 /* Check that CLASS_DECL somehow implements all inherited abstract
6193 methods. */
6195 static void
6197 tree class_decl;
6198 {
6204 return;
6206 /* Check for inherited types */
6208 do {
6213 /* Check for implemented interfaces. */
6216 {
6219 }
6220 }
6222 /* Check all the types method DECL uses and return 1 if all of them
6223 are now complete, 0 otherwise. This is used to check whether its
6224 safe to build a method signature or not. */
6226 static int
6228 tree decl;
6229 {
6231 tree args;
6244 }
6246 /* Visible interface to check methods contained in CLASS_DECL */
6248 void
6250 tree class_decl;
6251 {
6253 return;
6257 else
6261 }
6263 /* Check all the methods of CLASS_DECL. Methods are first completed
6264 then checked according to regular method existance rules. If no
6265 constructor for CLASS_DECL were encountered, then build its
6266 declaration. */
6268 static void
6270 tree class_decl;
6271 {
6273 tree method;
6276 tree mthrows;
6278 /* It is not necessary to check methods defined in java.lang.Object */
6280 return;
6285 /* Should take interfaces into account. FIXME */
6287 {
6288 tree sig;
6292 /* Check for redefinitions */
6294 continue;
6296 /* If we see one constructor a mark so we don't generate the
6297 default one. Also skip other verifications: constructors
6298 can't be inherited hence hiden or overriden */
6300 {
6302 continue;
6303 }
6305 /* We verify things thrown by the method. They must inherits from
6306 java.lang.Throwable */
6309 {
6311 parse_error_context
6312 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6313 IDENTIFIER_POINTER
6315 }
6320 /* Inner class can't declare static methods */
6322 {
6324 parse_error_context
6325 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6328 }
6330 /* Nothing overrides or it's a private method. */
6332 continue;
6334 {
6336 continue;
6337 }
6339 /* If `found' is declared in an interface, make sure the
6340 modifier matches. */
6344 {
6346 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6350 }
6352 /* Can't override a method with the same name and different return
6353 types. */
6355 {
6358 parse_error_context
6362 IDENTIFIER_POINTER
6365 }
6369 /* Can't override final. Can't override static. */
6371 {
6372 /* Static *can* override static */
6374 continue;
6375 parse_error_context
6381 IDENTIFIER_POINTER
6383 continue;
6384 }
6386 /* Static method can't override instance method. */
6388 {
6389 parse_error_context
6391 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
6393 IDENTIFIER_POINTER
6395 continue;
6396 }
6398 /* - Overriding/hiding public must be public
6399 - Overriding/hiding protected must be protected or public
6400 - If the overriden or hidden method has default (package)
6401 access, then the overriding or hiding method must not be
6402 private; otherwise, a compile-time error occurs. If
6403 `found' belongs to an interface, things have been already
6404 taken care of. */
6411 {
6412 parse_error_context
6414 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6417 IDENTIFIER_POINTER (DECL_NAME
6419 continue;
6420 }
6422 /* Overriding methods must have compatible `throws' clauses on checked
6423 exceptions, if any */
6426 /* Inheriting multiple methods with the same signature. FIXME */
6427 }
6432 /* Search for inherited abstract method not yet implemented in this
6433 class. */
6437 abort ();
6438 }
6440 /* Return a non zero value if the `throws' clause of METHOD (if any)
6441 is incompatible with the `throws' clause of FOUND (if any). */
6443 static void
6446 {
6449 /* Can't check these things with class loaded from bytecode. FIXME */
6451 return;
6455 {
6456 /* We don't verify unchecked expressions */
6458 continue;
6459 /* Checked expression must be compatible */
6463 break;
6465 {
6466 parse_error_context
6467 (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'",
6470 IDENTIFIER_POINTER
6472 }
6473 }
6474 }
6476 /* Check abstract method of interface INTERFACE */
6478 static void
6480 tree interface_decl;
6481 {
6487 {
6488 /* 2- Check for double definition inside the defining interface */
6490 continue;
6492 /* 3- Overriding is OK as far as we preserve the return type and
6493 the thrown exceptions (FIXME) */
6496 {
6499 parse_error_context
6503 IDENTIFIER_POINTER
6506 continue;
6507 }
6508 }
6510 /* 4- Inherited methods can't differ by their returned types */
6512 return;
6515 {
6519 continue;
6522 sub_interface_method;
6524 {
6526 sub_interface_method);
6528 {
6529 parse_error_context
6531 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6534 IDENTIFIER_POINTER
6537 IDENTIFIER_POINTER
6539 }
6540 }
6541 }
6542 }
6544 /* Lookup methods in interfaces using their name and partial
6545 signature. Return a matching method only if their types differ. */
6547 static tree
6550 {
6555 return NULL_TREE;
6559 {
6564 return to_return;
6565 }
6567 {
6568 to_return = lookup_java_interface_method2
6571 return to_return;
6572 }
6574 return NULL_TREE;
6575 }
6577 /* Lookup method using their name and partial signature. Return a
6578 matching method only if their types differ. */
6580 static tree
6584 {
6594 {
6597 {
6604 return method;
6605 }
6607 }
6608 return NULL_TREE;
6609 }
6611 /* Return the line that matches DECL line number, and try its best to
6612 position the column number. Used during error reports. */
6614 static tree
6616 tree decl;
6617 {
6622 return NULL_TREE;
6625 {
6628 }
6641 return cl;
6642 }
6644 /* Look for a simple name in the single-type import list */
6646 static tree
6648 tree name;
6649 {
6650 tree node;
6656 return NULL_TREE;
6657 }
6659 /* Process all single-type import. */
6661 static int
6662 process_imports ()
6663 {
6664 tree import;
6668 {
6677 /* Don't load twice something already defined. */
6679 continue;
6682 {
6683 tree left;
6687 error_found =
6690 /* We found it, we can bail out */
6692 break;
6694 /* We haven't found it. Maybe we're trying to access an
6695 inner class. The only way for us to know is to try again
6696 after having dropped a qualifier. If we can't break it further,
6697 we have an error. */
6699 break;
6702 }
6704 {
6707 original_name);
6709 }
6714 }
6716 }
6718 /* Possibly find and mark a class imported by a single-type import
6719 statement. */
6721 static void
6723 tree enclosing_type;
6724 tree class_type;
6725 {
6729 {
6731 {
6734 return;
6735 }
6737 }
6738 }
6740 static int
6744 {
6745 tree node;
6750 else
6756 }
6758 /* Read a import directory, gathering potential match for further type
6759 references. Indifferently reads a filesystem or a ZIP archive
6760 directory. */
6762 static void
6764 tree wfl;
6765 {
6779 return;
6786 {
6790 {
6798 else
6799 {
6803 {
6806 }
6810 {
6817 continue;
6819 current_entry_len);
6820 }
6821 }
6822 }
6823 else
6824 {
6830 {
6833 }
6838 continue;
6840 for (;;)
6841 {
6846 break;
6853 }
6856 }
6857 }
6861 /* Here we should have a unified way of retrieving an entry, to be
6862 indexed. */
6864 {
6867 {
6868 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
6869 java_error_count++;
6871 }
6872 else
6874 package_name);
6876 return;
6877 }
6879 }
6881 /* Possibly find a type in the import on demands specified
6882 types. Returns 1 if an error occured, 0 otherwise. Run throught the
6883 entire list, to detected potential double definitions. */
6885 static int
6887 tree enclosing_type;
6888 tree class_type;
6889 {
6893 tree node;
6897 {
6910 {
6912 {
6916 }
6917 else
6918 {
6919 seen_once++;
6920 parse_error_context
6925 }
6926 }
6928 }
6931 {
6932 /* Setup lineno so that it refers to the line of the import (in
6933 case we parse a class file and encounter errors */
6934 tree decl;
6940 /* If there is no DECL set for the class or if the class isn't
6941 loaded and not seen in source yet, the load */
6944 {
6947 }
6951 else
6952 /* 6.6.1: Inner classes are subject to member access rules. */
6954 }
6955 else
6957 }
6959 /* Add package NAME to the list of package encountered so far. To
6960 speed up class lookup in do_resolve_class, we make sure a
6961 particular package is added only once. */
6963 static void
6965 tree name;
6966 {
6970 {
6974 }
6977 {
6980 }
6981 }
6983 static tree
6986 {
6991 /* The trick is to determine when the package name stops and were
6992 the name of something contained in the package starts. Then we
6993 return a fully qualified name of what we want to get. */
6995 /* Do a quick search on well known package names */
6997 {
7001 }
7003 {
7006 }
7008 /* If we found something here, return */
7010 return type_name;
7014 /* Try to progressively construct a type name */
7018 {
7019 /* If we don't have what we're expecting, exit now. TYPE_NAME
7020 will be null and the error caught later. */
7022 break;
7025 {
7027 /* resolve_package should be used in a loop, hence we
7028 point at this one to naturally process the next one at
7029 the next iteration. */
7031 break;
7032 }
7033 }
7034 return type_name;
7035 }
7037 static tree
7041 {
7045 sub++;
7049 }
7051 /* Check accessibility of inner classes according to member access rules.
7052 DECL is the inner class, ENCLOSING_DECL is the class from which the
7053 access is being attempted. */
7055 static void
7058 {
7060 tree enclosing_decl_type;
7062 /* We don't issue an error message when CL is null. CL can be null
7063 as a result of processing a JDEP crafted by source_start_java_method
7064 for the purpose of patching its parm decl. But the error would
7065 have been already trapped when fixing the method's signature.
7066 DECL can also be NULL in case of earlier errors. */
7068 return;
7073 {
7074 /* Access is permitted only within the body of the top-level
7075 class in which DECL is declared. */
7082 return;
7084 }
7086 {
7087 tree decl_context;
7088 /* Access is permitted from within the same package... */
7090 return;
7092 /* ... or from within the body of a subtype of the context in which
7093 DECL is declared. */
7096 {
7098 {
7100 enclosing_decl_type))
7101 return;
7102 }
7103 else
7104 {
7105 /* Eww. The order of the arguments is different!! */
7108 return;
7109 }
7111 }
7113 }
7115 {
7116 /* Access is permitted only from within the same package as DECL. */
7118 return;
7120 }
7121 else
7122 /* Class is public. */
7123 return;
7128 }
7130 /* Accessibility check for top-level classes. If CLASS_NAME is in a foreign
7131 package, it must be PUBLIC. Return 0 if no access violations were found,
7132 1 otherwise. */
7134 static int
7136 tree class_name;
7137 tree cl;
7138 {
7139 tree type;
7148 {
7149 /* Access to a private class within the same package is
7150 allowed. */
7154 /* Both in the empty package. */
7157 /* Both in the same package. */
7160 parse_error_context
7161 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7165 }
7167 }
7169 /* Local variable declaration. */
7171 static void
7174 tree type;
7175 tree vlist;
7176 {
7182 /* Push a new block if statements were seen between the last time we
7183 pushed a block and now. Keep a count of blocks to close */
7185 {
7188 }
7191 {
7196 else
7197 {
7198 parse_error_context
7201 return;
7202 }
7203 }
7205 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7206 hold the TYPE value if a new incomplete has to be created (as
7207 opposed to being found already existing and reused). */
7210 /* If TYPE is fully resolved and we don't have a reference, make one */
7213 /* Go through all the declared variables */
7216 {
7222 /* Process NAME, as it may specify extra dimension(s) for it */
7225 /* Variable redefinition check */
7227 {
7230 continue;
7231 }
7233 /* Type adjustment. We may have just readjusted TYPE because
7234 the variable specified more dimensions. Make sure we have
7235 a reference if we can and don't have one already. */
7239 /* Never layout this decl. This will be done when its scope
7240 will be entered */
7246 /* If doing xreferencing, replace the line number with the WFL
7247 compound value */
7251 /* Don't try to use an INIT statement when an error was found */
7255 /* Add the initialization function to the current function's code */
7257 {
7258 /* Name might have been readjusted */
7263 init));
7264 }
7266 /* Setup dependency the type of the decl */
7268 {
7273 }
7274 }
7276 }
7278 /* Called during parsing. Build decls from argument list. */
7280 static void
7282 tree fndecl;
7283 {
7284 tree tem;
7285 tree parm_decl;
7289 return;
7293 /* New scope for the function */
7294 enter_block ();
7297 {
7301 /* If type is incomplete. Create an incomplete decl and ask for
7302 the decl to be patched later */
7304 {
7313 }
7314 else
7317 /* Remember if a local variable was declared final (via its
7318 TREE_LIST of type/name.) Set LOCAL_FINAL accordingly. */
7320 {
7323 }
7326 }
7332 }
7334 /* Called during parsing. Creates an artificial method declaration. */
7336 static tree
7338 tree class;
7341 {
7342 tree mdecl;
7344 java_parser_context_save_global ();
7350 java_parser_context_restore_global ();
7352 return mdecl;
7353 }
7355 /* Starts the body if an artifical method. */
7357 static void
7359 tree mdecl;
7360 {
7364 enter_block ();
7365 }
7367 static void
7369 tree mdecl;
7370 {
7371 /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7372 It has to be evaluated first. (if mdecl is current_function_decl,
7373 we have an undefined behavior if no temporary variable is used.) */
7376 exit_block ();
7377 }
7379 /* Terminate a function and expand its body. */
7381 static void
7382 source_end_java_method ()
7383 {
7387 return;
7389 java_parser_context_save_global ();
7392 /* Turn function bodies with only a NOP expr null, so they don't get
7393 generated at all and we won't get warnings when using the -W
7394 -Wall flags. */
7398 /* Generate function's code */
7400 && ! flag_emit_class_files
7404 /* pop out of its parameters */
7409 /* Generate rtl for function exit. */
7411 {
7415 /* Run the optimizers and output assembler code for this function. */
7417 }
7420 java_parser_context_restore_global ();
7421 }
7423 /* Record EXPR in the current function block. Complements compound
7424 expression second operand if necessary. */
7426 tree
7429 {
7431 return NULL_TREE;
7433 }
7435 static tree
7438 {
7442 return body;
7445 return body;
7449 return c;
7450 }
7452 /* Add STMT to EXISTING if possible, otherwise create a new
7453 COMPOUND_EXPR and add STMT to it. */
7455 static tree
7458 {
7461 else
7462 return stmt;
7463 }
7466 {
7469 tree current;
7472 {
7478 {
7481 }
7482 else
7483 break;
7484 }
7485 }
7487 void
7488 java_reorder_fields ()
7489 {
7492 tree current;
7494 /* Register STOP_REORDERING with the garbage collector. */
7496 {
7499 }
7502 {
7506 break;
7508 /* Reverse the fields, but leave the dummy field in front.
7509 Fields are already ordered for Object and Class */
7512 {
7513 /* If the dummy field is there, reverse the right fields and
7514 just layout the type for proper fields offset */
7516 {
7520 }
7521 /* We don't have a dummy field, we need to layout the class,
7522 after having reversed the fields */
7523 else
7524 {
7528 }
7529 }
7530 }
7531 /* There are cases were gclass_list will be empty. */
7534 }
7536 /* Layout the methods of all classes loaded in one way or another.
7537 Check methods of source parsed classes. Then reorder the
7538 fields and layout the classes or the type of all source parsed
7539 classes */
7541 void
7542 java_layout_classes ()
7543 {
7544 tree current;
7547 /* Layout the methods of all classes seen so far */
7548 java_layout_seen_class_methods ();
7549 java_parse_abort_on_error ();
7552 /* Then check the methods of all parsed classes */
7556 java_parse_abort_on_error ();
7559 {
7563 /* Error reported by the caller */
7565 return;
7566 }
7568 /* We might have reloaded classes durign the process of laying out
7569 classes for code generation. We must layout the methods of those
7570 late additions, as constructor checks might use them */
7571 java_layout_seen_class_methods ();
7572 java_parse_abort_on_error ();
7573 }
7575 /* Expand methods in the current set of classes rememebered for
7576 generation. */
7578 static void
7579 java_complete_expand_classes ()
7580 {
7581 tree current;
7588 }
7590 /* Expand the methods found in OUTER, starting first by OUTER's inner
7591 classes, if any. */
7593 static void
7595 tree outer;
7596 {
7597 tree inner_list;
7601 /* We need to go after all inner classes and start expanding them,
7602 starting with most nested ones. We have to do that because nested
7603 classes might add functions to outer classes */
7611 }
7613 /* Expand methods registered in CLASS_DECL. The general idea is that
7614 we expand regular methods first. This allows us get an estimate on
7615 how outer context local alias fields are really used so we can add
7616 to the constructor just enough code to initialize them properly (it
7617 also lets us generate finit$ correctly.) Then we expand the
7618 constructors and then <clinit>. */
7620 static void
7622 tree class_decl;
7623 {
7628 /* Find whether the class has final variables */
7631 {
7633 break;
7634 }
7636 /* Initialize a new constant pool */
7637 init_outgoing_cpool ();
7639 /* Pre-expand <clinit> to figure whether we really need it or
7640 not. If we do need it, we pre-expand the static fields so they're
7641 ready to be used somewhere else. <clinit> will be fully expanded
7642 after we processed the constructors. */
7646 /* Then generate finit$ (if we need to) because constructors will
7647 try to use it.*/
7651 /* Then generate instinit$ (if we need to) because constructors will
7652 try to use it. */
7656 /* Now do the constructors */
7658 {
7662 continue;
7665 /* Don't generate debug info on line zero when expanding a
7666 generated constructor. */
7670 /* Reset the final local variable assignment flags */
7676 /* Check for missed out final variable assignment */
7682 }
7684 /* First, do the ordinary methods. */
7686 {
7687 /* Ctors aren't part of this batch. */
7689 continue;
7691 /* Skip abstract or native methods -- but do handle native
7692 methods when generating JNI stubs. */
7694 {
7696 continue;
7697 }
7700 {
7703 }
7706 }
7708 /* If there is indeed a <clinit>, fully expand it now */
7710 {
7711 /* Reset the final local variable assignment flags */
7714 /* Prevent the use of `this' inside <clinit> */
7718 /* Check for missed out static final variable assignment */
7722 }
7724 /* We might have generated a class$ that we now want to expand */
7728 /* Now verify constructor circularity (stop after the first one we
7729 prove wrong.) */
7734 break;
7736 /* Final check on the initialization of final variables. */
7738 {
7740 /* If we have an interface, check for uninitialized fields. */
7743 }
7745 /* Save the constant pool. We'll need to restore it later. */
7747 }
7749 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7750 safely used in some other methods/constructors. */
7752 static tree
7754 tree class_type;
7755 {
7759 return NULL_TREE;
7761 /* Go through all static fields and pre expand them */
7767 /* Then build the <clinit> method */
7774 /* We process the list of assignment we produced as the result of
7775 the declaration of initialized static field and add them as
7776 statement to the <clinit> method. */
7779 {
7781 /* We build the assignment expression that will initialize the
7782 field to its value. There are strict rules on static
7783 initializers (8.5). FIXME */
7787 }
7791 /* Now we want to place <clinit> as the last method (because we need
7792 it at least for interface so that it doesn't interfere with the
7793 dispatch table based lookup. */
7795 {
7804 }
7806 return mdecl;
7807 }
7809 /* Analyzes a method body and look for something that isn't a
7810 MODIFY_EXPR with a constant value. */
7812 static int
7814 tree bbody;
7815 {
7818 {
7819 case BLOCK:
7821 break;
7823 case EXPR_WITH_FILE_LOCATION:
7825 break;
7827 case COMPOUND_EXPR:
7831 break;
7833 case MODIFY_EXPR:
7834 /* If we're generating to class file and we're dealing with an
7835 array initialization, we return 1 to keep <clinit> */
7839 /* Return 0 if the operand is constant, 1 otherwise. */
7842 default:
7844 }
7846 }
7849 /* See whether we could get rid of <clinit>. Criteria are: all static
7850 final fields have constant initial values and the body of <clinit>
7851 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7853 static int
7855 tree mdecl;
7856 {
7864 /* If the body isn't empty, then we keep <clinit>. Note that if
7865 we're emitting classfiles, this isn't enough not to rule it
7866 out. */
7871 else
7881 {
7882 tree f_init;
7884 /* We're not interested in non static field */
7886 continue;
7888 /* nor in fields with initializers. */
7892 continue;
7894 /* Anything that isn't String or a basic type is ruled out -- or
7895 if we know how to deal with it (when doing things natively) we
7896 should generated an empty <clinit> so that SUID are computed
7897 correctly. */
7900 break;
7903 break;
7904 }
7906 /* Now we analyze the method body and look for something that
7907 isn't a MODIFY_EXPR */
7910 else
7916 /* Get rid of <clinit> in the class' list of methods */
7919 else
7923 {
7925 break;
7926 }
7929 }
7931 /* Install the argument from MDECL. Suitable to completion and
7932 expansion of mdecl's body. */
7934 static void
7936 tree mdecl;
7937 {
7945 {
7948 if (PROMOTE_PROTOTYPES
7958 }
7963 }
7966 /* Complete and expand a method. */
7968 static void
7970 tree mdecl;
7971 {
7975 /* Fix constructors before expanding them */
7979 /* Expand functions that have a body */
7981 return;
7996 /* Prepare the function for tree completion */
7999 /* Install the current this */
8003 /* Purge the `throws' list of unchecked exceptions (we save a copy
8004 of the list and re-install it later.) */
8008 /* Install exceptions thrown with `throws' */
8012 {
8015 /* Before we check initialization, attached all class initialization
8016 variable to the block_body */
8021 {
8024 /* Go through all the flags marking the initialization of
8025 static variables and see whether they're definitively
8026 assigned, in which case the type is remembered as
8027 definitively initialized in MDECL. */
8029 {
8033 /* Always register the context as properly initialized in
8034 MDECL. This used with caution helps removing extra
8035 initialization of self. */
8040 }
8041 }
8043 }
8047 /* If we saw a return but couldn't evaluate it properly, we'll have
8048 an error_mark_node here. */
8055 /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8058 /* Pop the current level, with special measures if we found errors. */
8063 /* Pop the exceptions and sanity check */
8064 POP_EXCEPTIONS();
8066 abort ();
8068 /* Restore the copy of the list of exceptions if emitting xrefs. */
8070 }
8072 /* For with each class for which there's code to generate. */
8074 static void
8076 tree class;
8077 {
8078 tree decl;
8080 {
8082 continue;
8086 /* It's time to assign the variable flagging static class
8087 initialization based on which classes invoked static methods
8088 are definitely initializing. This should be flagged. */
8093 /* Prepare the function for RTL expansion */
8096 /* Expand function start, generate initialization flag
8097 assignment, and handle synchronized methods. */
8100 /* Expand the rest of the function body and terminate
8101 expansion. */
8102 source_end_java_method ();
8103 }
8104 }
8106 \f
8108 /* This section of the code deals with accessing enclosing context
8109 fields either directly by using the relevant access to this$<n> or
8110 by invoking an access method crafted for that purpose. */
8112 /* Build the necessary access from an inner class to an outer
8113 class. This routine could be optimized to cache previous result
8114 (decl, current_class and returned access). When an access method
8115 needs to be generated, it always takes the form of a read. It might
8116 be later turned into a write by calling outer_field_access_fix. */
8118 static tree
8121 {
8126 /* If the immediate enclosing context of the current class is the
8127 field decl's class or inherits from it; build the access as
8128 `this$<n>.<field>'. Note that we will break the `private' barrier
8129 if we're not emitting bytecodes. */
8132 {
8136 }
8137 /* Otherwise, generate access methods to outer this and access the
8138 field (either using an access method or by direct access.) */
8139 else
8140 {
8143 /* Now we chain the required number of calls to the access$0 to
8144 get a hold to the enclosing instance we need, and then we
8145 build the field access. */
8148 /* If the field is private and we're generating bytecode, then
8149 we generate an access method */
8151 {
8155 }
8156 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8157 Once again we break the `private' access rule from a foreign
8158 class. */
8159 else
8161 }
8163 }
8165 /* Return a non zero value if NODE describes an outer field inner
8166 access. */
8168 static int
8171 {
8177 /* If the inner class extends the declaration context of the field
8178 we're try to acces, then this isn't an outer field access */
8184 {
8189 {
8190 /* Before we give up, see whether the field is inherited from
8191 the enclosing context we're considering. */
8194 break;
8195 }
8196 }
8199 }
8201 /* Return a non zero value if NODE represents an outer field inner
8202 access that was been already expanded. As a side effect, it returns
8203 the name of the field being accessed and the argument passed to the
8204 access function, suitable for a regeneration of the access method
8205 call if necessary. */
8207 static int
8210 {
8216 /* Well, gcj generates slightly different tree nodes when compiling
8217 to native or bytecodes. It's the case for function calls. */
8219 if (flag_emit_class_files
8224 {
8229 {
8233 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8236 }
8237 }
8240 {
8245 }
8246 return identified;
8247 }
8249 /* Detect in NODE an outer field read access from an inner class and
8250 transform it into a write with RHS as an argument. This function is
8251 called from the java_complete_lhs when an assignment to a LHS can
8252 be identified. */
8254 static tree
8257 {
8261 {
8262 /* At any rate, check whether we're trying to assign a value to
8263 a final. */
8268 return error_mark_node;
8273 }
8274 return NULL_TREE;
8275 }
8277 /* Construct the expression that calls an access method:
8278 <type>.access$<n>(<arg1> [, <arg2>]);
8280 ARG2 can be NULL and will be omitted in that case. It will denote a
8281 read access. */
8283 static tree
8287 {
8300 }
8302 static tree
8303 build_new_access_id ()
8304 {
8310 }
8312 /* Create the static access functions for the outer field DECL. We define a
8313 read:
8314 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8315 return inst$.field;
8316 }
8317 and a write access:
8318 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8319 TREE_TYPE (<field>) value$) {
8320 return inst$.field = value$;
8321 }
8322 We should have a usage flags on the DECL so we can lazily turn the ones
8323 we're using for code generation. FIXME.
8324 */
8326 static tree
8328 tree decl;
8329 {
8337 /* Create the identifier and a function named after it. */
8340 /* The identifier is marked as bearing the name of a generated write
8341 access function for outer field accessed from inner classes. */
8344 /* Create the read access */
8354 /* Create the write access method. No write access for final variable */
8356 {
8368 }
8371 /* Return the access name */
8373 }
8375 /* Build an field access method NAME. */
8377 static tree
8380 {
8383 /* Create the method */
8388 /* Attach the method body. */
8395 return mdecl;
8396 }
8398 \f
8399 /* This section deals with building access function necessary for
8400 certain kinds of method invocation from inner classes. */
8402 static tree
8404 tree decl;
8405 {
8412 /* Test this abort with an access to a private field */
8414 abort ();
8416 /* Check the cache first */
8422 /* Obtain an access identifier and mark it */
8427 /* Create the arguments, as much as the original */
8430 {
8434 }
8437 /* Create the method */
8441 /* There is a potential bug here. We should be able to use
8442 fix_method_argument_names, but then arg names get mixed up and
8443 eventually a constructor will have its this$0 altered and the
8444 outer context won't be assignment properly. The test case is
8445 stub.java FIXME */
8448 /* Attach the method body. */
8452 /* The actual method invocation uses the same args. When invoking a
8453 static methods that way, we don't want to skip the first
8454 argument. */
8460 call_args);
8463 call_args);
8473 /* Back tag the access function so it know what it accesses */
8476 /* Tag the current method so it knows it has an access generated */
8478 }
8480 \f
8481 /* This section of the code deals with building expressions to access
8482 the enclosing instance of an inner class. The enclosing instance is
8483 kept in a generated field called this$<n>, with <n> being the
8484 inner class nesting level (starting from 0.) */
8486 /* Build an access to a given this$<n>, always chaining access call to
8487 others. Access methods to this$<n> are build on the fly if
8488 necessary. This CAN'T be used to solely access this$<n-1> from
8489 this$<n> (which alway yield to special cases and optimization, see
8490 for example build_outer_field_access). */
8492 static tree
8496 {
8500 {
8502 {
8505 }
8506 else
8507 {
8517 }
8519 /* if FROM isn't an inter class, that's fine, we've done
8520 enough. What we're looking for can be accessed from there. */
8523 break;
8525 }
8526 return access;
8527 }
8529 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8530 is returned if nothing needs to be generated. Otherwise, the method
8531 generated and a method decl is returned.
8533 NOTE: These generated methods should be declared in a class file
8534 attribute so that they can't be referred to directly. */
8536 static tree
8538 tree type;
8539 {
8541 tree saved_current_function_decl;
8543 /* If TYPE is a top-level class, no access method is required.
8544 If there already is such an access method, bail out. */
8546 return NULL_TREE;
8548 /* We generate the method. The method looks like:
8549 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8550 */
8571 return mdecl;
8572 }
8574 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8575 the first level of innerclassing. this$1 for the next one, etc...
8576 This function can be invoked with TYPE to NULL, available and then
8577 has to count the parser context. */
8579 static tree
8581 tree type;
8582 {
8588 tree decl;
8592 /* Register SAVED_THISN and SAVED_TYPE with the garbage collector. */
8594 {
8598 }
8601 {
8604 else
8605 {
8608 ;
8612 }
8613 }
8614 else
8618 return saved_thisn;
8623 return saved_thisn;
8624 }
8626 /* Return the assignement to the hidden enclosing context `this$<n>'
8627 by the second incoming parameter to the innerclass constructor. The
8628 form used is `this.this$<n> = this$<n>;'. */
8630 static tree
8631 build_thisn_assign ()
8632 {
8634 {
8641 }
8642 return NULL_TREE;
8643 }
8645 \f
8646 /* Building the synthetic `class$' used to implement the `.class' 1.1
8647 extension for non primitive types. This method looks like:
8649 static Class class$(String type) throws NoClassDefFoundError
8650 {
8651 try {return (java.lang.Class.forName (String));}
8652 catch (ClassNotFoundException e) {
8653 throw new NoClassDefFoundError(e.getMessage());}
8654 } */
8656 static tree
8658 tree class;
8659 {
8660 #define BWF(S) build_wfl_node (get_identifier ((S)))
8661 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8668 {
8673 }
8675 /* Build the arguments */
8680 /* Build the qualified name java.lang.Class.forName */
8686 /* Create the "class$" function */
8693 /* We start by building the try block. We need to build:
8694 return (java.lang.Class.forName (type)); */
8699 /* Now onto the catch block. We start by building the expression
8700 throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8705 /* Build new NoClassDefFoundError (_.getMessage) */
8706 throw_stmt = build_new_invocation
8710 /* Build the throw, (it's too early to use BUILD_THROW) */
8713 /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8726 return mdecl;
8727 }
8729 static tree
8731 tree type;
8732 {
8737 else
8740 /* Ensure that the proper name separator is used */
8748 }
8750 /* This section of the code deals with constructor. */
8752 /* Craft a body for default constructor. Patch existing constructor
8753 bodies with call to super() and field initialization statements if
8754 necessary. */
8756 static void
8758 tree mdecl;
8759 {
8766 return;
8770 {
8771 /* It is an error for the compiler to generate a default
8772 constructor if the superclass doesn't have a constructor that
8773 takes no argument, or the same args for an anonymous class */
8775 {
8780 parse_error_context
8785 }
8787 /* The constructor body must be crafted by hand. It's the
8788 constructor we defined when we realize we didn't have the
8789 CLASSNAME() constructor */
8792 /* Insert an assignment to the this$<n> hidden field, if
8793 necessary */
8797 /* We don't generate a super constructor invocation if we're
8798 compiling java.lang.Object. build_super_invocation takes care
8799 of that. */
8802 /* FIXME */
8807 }
8808 /* Search for an explicit constructor invocation */
8809 else
8810 {
8818 {
8819 case CALL_EXPR:
8824 break;
8825 case COMPOUND_EXPR:
8826 case EXPR_WITH_FILE_LOCATION:
8829 break;
8830 case BLOCK:
8833 break;
8834 default:
8837 }
8839 /* Generate the assignment to this$<n>, if necessary */
8843 /* The constructor is missing an invocation of super() */
8847 /* Explicit super() invokation should take place before the
8848 instance initializer blocks. */
8849 else
8850 {
8854 }
8856 /* Insert the instance initializer block right after. */
8860 /* Fix the constructor main block if we're adding extra stmts */
8862 {
8866 }
8867 }
8868 }
8870 /* Browse constructors in the super class, searching for a constructor
8871 that doesn't take any argument. Return 0 if one is found, 1
8872 otherwise. If the current class is an anonymous inner class, look
8873 for something that has the same signature. */
8875 static int
8877 tree mdecl;
8878 {
8881 tree sdecl;
8887 {
8888 tree mdecl_arg_type;
8892 {
8893 tree m_arg_type;
8902 if (!valid_method_invocation_conversion_p
8905 break;
8909 }
8910 }
8911 else
8912 {
8914 {
8920 }
8921 }
8923 }
8925 /* Generate code for all context remembered for code generation. */
8927 void
8928 java_expand_classes ()
8929 {
8933 java_parse_abort_on_error ();
8935 return;
8936 java_layout_classes ();
8937 java_parse_abort_on_error ();
8941 {
8946 java_parse_abort_on_error ();
8947 }
8950 /* Find anonymous classes and expand their constructor, now they
8951 have been fixed. */
8953 {
8954 tree current;
8957 {
8960 {
8961 tree d;
8963 {
8965 {
8970 }
8971 }
8972 }
8973 }
8974 }
8976 /* If we've found error at that stage, don't try to generate
8977 anything, unless we're emitting xrefs or checking the syntax only
8978 (but not using -fsyntax-only for the purpose of generating
8979 bytecode. */
8982 return;
8984 /* Now things are stable, go for generation of the class data. */
8986 {
8987 tree current;
8990 {
8998 {
9000 finish_class ();
9001 }
9002 }
9003 }
9004 }
9006 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9007 a tree list node containing RIGHT. Fore coming RIGHTs will be
9008 chained to this hook. LOCATION contains the location of the
9009 separating `.' operator. */
9011 static tree
9015 {
9016 tree wfl;
9020 else
9021 {
9023 /* If wfl wasn't qualified, we build a first anchor */
9026 }
9028 /* And chain them */
9032 return wfl;
9033 }
9035 /* Simple merge of two name separated by a `.' */
9037 static tree
9040 {
9041 tree node;
9043 return NULL_TREE;
9046 return right;
9049 return left;
9059 return node;
9060 }
9062 /* Merge the two parts of a qualified name into LEFT. Set the
9063 location information of the resulting node to LOCATION, usually
9064 inherited from the location information of the `.' operator. */
9066 static tree
9070 {
9071 #ifdef USE_COMPONENT_REF
9074 return node;
9075 #else
9082 /* Left wasn't qualified and is now qualified */
9084 {
9088 }
9095 return left;
9096 #endif
9097 }
9099 /* Extract the last identifier component of the qualified in WFL. The
9100 last identifier is removed from the linked list */
9102 static tree
9104 tree wfl;
9105 {
9106 tree q;
9110 {
9112 /* Operating on a non qualified qualified WFL. */
9113 abort ();
9117 }
9118 }
9120 /* Resolve the expression name NAME. Return its decl. */
9122 static tree
9124 tree id;
9126 {
9128 tree decl;
9130 /* 6.5.5.1: Simple expression names */
9132 {
9133 /* 15.13.1: NAME can appear within the scope of a local variable
9134 declaration */
9136 return decl;
9138 /* 15.13.1: NAME can appear within a class declaration */
9139 else
9140 {
9143 {
9147 /* If we're accessing an outer scope local alias, make
9148 sure we change the name of the field we're going to
9149 build access to. */
9153 /* Instance variable (8.3.1.1) can't appear within
9154 static method, static initializer or initializer for
9155 a static variable. */
9157 {
9159 return error_mark_node;
9160 }
9161 /* Instance variables can't appear as an argument of
9162 an explicit constructor invocation */
9165 {
9166 parse_error_context
9167 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9168 return error_mark_node;
9169 }
9171 /* If we're processing an inner class and we're trying
9172 to access a field belonging to an outer class, build
9173 the access to the field */
9175 {
9177 {
9179 return error_mark_node;
9180 }
9184 return access;
9185 }
9187 /* Otherwise build what it takes to access the field */
9192 /* We may be asked to save the real field access node */
9195 /* And we return what we got */
9196 return access;
9197 }
9198 /* Fall down to error report on undefined variable */
9199 }
9200 }
9201 /* 6.5.5.2 Qualified Expression Names */
9202 else
9203 {
9207 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9208 /* 15.10.2: Accessing Superclass Members using super */
9210 }
9212 /* We've got an error here */
9215 "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9217 IDENTIFIER_POINTER (DECL_NAME
9219 else
9223 return error_mark_node;
9224 }
9226 static void
9229 {
9230 parse_error_context
9235 }
9237 /* 15.10.1 Field Acess Using a Primary and/or Expression Name.
9238 We return something suitable to generate the field access. We also
9239 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
9240 recipient's address can be null. */
9242 static tree
9244 tree qual_wfl;
9246 {
9248 tree field_ref;
9253 return error_mark_node;
9255 /* Resolve the LENGTH field of an array here */
9259 {
9263 /* In case we're dealing with a static array, we need to
9264 initialize its class before the array length can be fetched.
9265 It's also a good time to create a DECL_RTL for the field if
9266 none already exists, otherwise if the field was declared in a
9267 class found in an external file and hasn't been (and won't
9268 be) accessed for its value, none will be created. */
9270 {
9273 }
9274 }
9275 /* We might have been trying to resolve field.method(). In which
9276 case, the resolution is over and decl is the answer */
9280 {
9288 return error_mark_node;
9291 }
9292 else
9300 return field_ref;
9301 }
9303 /* If NODE is an access to f static field, strip out the class
9304 initialization part and return the field decl, otherwise, return
9305 NODE. */
9307 static tree
9309 tree node;
9310 {
9312 {
9315 {
9322 }
9324 return op1;
9325 }
9326 return node;
9327 }
9329 /* 6.5.5.2: Qualified Expression Names */
9331 static int
9333 tree wfl;
9335 {
9341 /* For certain for of inner class instantiation */
9343 #define RESTORE_THIS_AND_CURRENT_CLASS \
9349 {
9354 /* 15.10.1 Field Access Using a Primary */
9356 {
9357 case CALL_EXPR:
9358 case NEW_CLASS_EXPR:
9359 /* If the access to the function call is a non static field,
9360 build the code to access it. */
9362 {
9367 }
9369 /* And code for the function call */
9373 /* We might have to setup a new current class and a new this
9374 for the search of an inner class, relative to the type of
9375 a expression resolved as `decl'. The current values are
9376 saved and restored shortly after */
9379 if (decl
9381 || from_qualified_this))
9382 {
9383 /* If we still have `from_qualified_this', we have the form
9384 <T>.this.f() and we need to build <T>.this */
9386 {
9390 }
9394 }
9401 from_super,
9404 {
9405 RESTORE_THIS_AND_CURRENT_CLASS;
9407 }
9410 /* If we're creating an inner class instance, check for that
9411 an enclosing instance is in scope */
9414 {
9415 parse_error_context
9420 RESTORE_THIS_AND_CURRENT_CLASS;
9422 }
9424 /* In case we had to change then to resolve a inner class
9425 instantiation using a primary qualified by a `new' */
9426 RESTORE_THIS_AND_CURRENT_CLASS;
9428 /* EH check. No check on access$<n> functions */
9429 if (location
9430 && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9434 /* If the previous call was static and this one is too,
9435 build a compound expression to hold the two (because in
9436 that case, previous function calls aren't transported as
9437 forcoming function's argument. */
9439 {
9443 }
9444 else
9445 {
9448 }
9450 continue;
9452 case NEW_ARRAY_EXPR:
9453 case NEW_ANONYMOUS_ARRAY_EXPR:
9458 continue;
9460 case CONVERT_EXPR:
9466 continue;
9468 case CONDITIONAL_EXPR:
9469 case STRING_CST:
9470 case MODIFY_EXPR:
9475 continue;
9477 case ARRAY_REF:
9478 /* If the access to the function call is a non static field,
9479 build the code to access it. */
9481 {
9485 }
9486 /* And code for the array reference expression */
9491 continue;
9493 case PLUS_EXPR:
9500 break;
9502 case CLASS_LITERAL:
9507 break;
9509 default:
9510 /* Fix for -Wall Just go to the next statement. Don't
9511 continue */
9512 break;
9513 }
9515 /* If we fall here, we weren't processing a (static) function call. */
9518 /* It can be the keyword THIS */
9521 {
9523 {
9524 parse_error_context
9527 }
9530 {
9531 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9533 }
9534 /* We have to generate code for intermediate acess */
9536 {
9539 }
9540 /* We're trying to access the this from somewhere else. Make sure
9541 it's allowed before doing so. */
9542 else
9543 {
9545 {
9547 parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9552 }
9554 /* If there's nothing else after that, we need to
9555 produce something now, otherwise, the section of the
9556 code that needs to produce <T>.this will generate
9557 what is necessary. */
9559 {
9563 }
9564 }
9567 continue;
9568 }
9570 /* 15.10.2 Accessing Superclass Members using SUPER */
9573 {
9574 tree node;
9575 /* Check on the restricted use of SUPER */
9578 {
9579 parse_error_context
9582 }
9583 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9592 continue;
9593 }
9595 /* 15.13.1: Can't search for field name in packages, so we
9596 assume a variable/class name was meant. */
9598 {
9601 {
9602 tree list;
9604 /* We want to be absolutely sure that the class is laid
9605 out. We're going to search something inside it. */
9610 /* Fix them all the way down, if any are left. */
9612 {
9615 {
9619 }
9620 }
9621 }
9622 else
9623 {
9625 parse_error_context
9630 else
9631 parse_error_context
9635 }
9636 }
9638 /* We have a type name. It's been already resolved when the
9639 expression was qualified. */
9641 {
9644 /* Sneak preview. If next we see a `new', we're facing a
9645 qualification with resulted in a type being selected
9646 instead of a field. Report the error */
9649 {
9653 }
9656 {
9657 parse_error_context
9664 }
9669 }
9670 /* We resolve an expression name */
9671 else
9672 {
9675 /* If there exists an early resolution, use it. That occurs
9676 only once and we know that there are more things to
9677 come. Don't do that when processing something after SUPER
9678 (we need more thing to be put in place below */
9680 {
9683 {
9685 {
9688 else
9689 {
9691 current_class);
9693 }
9696 }
9697 else
9698 {
9702 }
9703 }
9704 }
9706 /* Report and error if we're using a numerical litteral as a
9707 qualifier. It can only be an INTEGER_CST. */
9709 {
9710 parse_error_context
9714 }
9716 /* We have to search for a field, knowing the type of its
9717 container. The flag FROM_TYPE indicates that we resolved
9718 the last member of the expression as a type name, which
9719 means that for the resolution of this field, we'll look
9720 for other errors than if it was resolved as a member of
9721 an other field. */
9722 else
9723 {
9728 {
9729 parse_error_context
9735 }
9740 /* Maybe what we're trying to access to is an inner
9741 class, only if decl is a TYPE_DECL. */
9743 {
9749 {
9754 continue;
9755 }
9756 }
9759 {
9760 parse_error_context
9765 }
9769 /* Layout the type of field_decl, since we may need
9770 it. Don't do primitive types or loaded classes. The
9771 situation of non primitive arrays may not handled
9772 properly here. FIXME */
9775 else
9782 /* Check on accessibility here */
9785 {
9786 parse_error_context
9789 java_accstring_lookup
9793 IDENTIFIER_POINTER
9796 }
9799 /* There are things to check when fields are accessed
9800 from type. There are no restrictions on a static
9801 declaration of the field when it is accessed from an
9802 interface */
9806 && !is_static
9807 && (current_function_decl
9809 {
9812 }
9815 /* It's an access from a type but it isn't static, we
9816 make it relative to `this'. */
9820 /* If we need to generate something to get a proper
9821 handle on what this field is accessed from, do it
9822 now. */
9824 {
9828 }
9830 /* We want to keep the location were found it, and the type
9831 we found. */
9835 /* Generate the correct expression for field access from
9836 qualified this */
9838 {
9841 }
9843 /* This is the decl found and eventually the next one to
9844 search from */
9846 }
9850 /* Sneak preview. If decl is qualified by a `new', report
9851 the error here to be accurate on the peculiar construct */
9855 {
9859 }
9860 }
9861 /* `q' might have changed due to a after package resolution
9862 re-qualification */
9864 break;
9865 }
9868 }
9870 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9871 can't be accessed from REFERENCE (a record type). If MEMBER
9872 features a protected access, we then use WHERE which, if non null,
9873 holds the type of MEMBER's access that is checked against
9874 6.6.2.1. This function should be used when decl is a field or a
9875 method. */
9877 static int
9880 tree where;
9882 {
9885 /* Inner classes are processed by check_inner_class_access */
9889 /* Access always granted for members declared public */
9893 /* Check access on protected members */
9895 {
9896 /* Access granted if it occurs from within the package
9897 containing the class in which the protected member is
9898 declared */
9902 /* If accessed with the form `super.member', then access is granted */
9906 /* If where is active, access was made through a
9907 qualifier. Access is granted if the type of the qualifier is
9908 or is a sublass of the type the access made from (6.6.2.1.) */
9912 /* Otherwise, access is granted if occuring from the class where
9913 member is declared or a subclass of it. Find the right
9914 context to perform the check */
9916 {
9918 {
9922 }
9923 }
9927 }
9929 /* Check access on private members. Access is granted only if it
9930 occurs from within the class in which it is declared -- that does
9931 it for innerclasses too. */
9933 {
9939 }
9941 /* Default access are permitted only when occuring within the
9942 package in which the type (REFERENCE) is declared. In other words,
9943 REFERENCE is defined in the current package */
9947 /* Otherwise, access is granted */
9949 }
9951 /* Test deprecated decl access. */
9952 static void
9955 {
9957 /* Complain if the field is deprecated and the file it was defined
9958 in isn't compiled at the same time the file which contains its
9959 use is */
9962 {
9965 {
9966 case FUNCTION_DECL:
9968 break;
9969 case FIELD_DECL:
9970 case VAR_DECL:
9972 break;
9973 case TYPE_DECL:
9976 return;
9977 default:
9978 abort ();
9979 }
9980 /* Don't issue a message if the context as been deprecated as a
9981 whole. */
9983 parse_warning_context
9987 }
9988 }
9990 /* Returns 1 if class was declared in the current package, 0 otherwise */
9992 static int
9994 tree class;
9995 {
9998 tree left;
10005 /* If the current package is empty and the name of CLASS is
10006 qualified, class isn't in the current package. If there is a
10007 current package and the name of the CLASS is not qualified, class
10008 isn't in the current package */
10012 /* If there is not package and the name of CLASS isn't qualified,
10013 they belong to the same unnamed package */
10017 /* Compare the left part of the name of CLASS with the package name */
10020 {
10022 /* Register CACHE with the garbage collector. */
10024 {
10027 }
10031 }
10033 }
10035 /* This function may generate code to access DECL from WHERE. This is
10036 done only if certain conditions meet. */
10038 static tree
10041 {
10047 return decl;
10048 }
10050 /* Build a method invocation, by patching PATCH. If non NULL
10051 and according to the situation, PRIMARY and WHERE may be
10052 used. IS_STATIC is set to 1 if the invoked function is static. */
10054 static tree
10061 {
10065 tree list;
10071 /* Should be overriden if everything goes well. Otherwise, if
10072 something fails, it should keep this value. It stop the
10073 evaluation of a bogus assignment. See java_complete_tree,
10074 MODIFY_EXPR: for the reasons why we sometimes want to keep on
10075 evaluating an assignment */
10078 /* Since lookup functions are messing with line numbers, save the
10079 context now. */
10080 java_parser_context_save_global ();
10082 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10084 /* Resolution of qualified name, excluding constructors */
10086 {
10088 /* Extract the last IDENTIFIER of the qualified
10089 expression. This is a wfl and we will use it's location
10090 data during error report. */
10094 /* Given the context, IDENTIFIER is syntactically qualified
10095 as a MethodName. We need to qualify what's before */
10106 PATCH_METHOD_RETURN_ERROR ();
10112 {
10113 parse_error_context
10117 PATCH_METHOD_RETURN_ERROR ();
10118 }
10123 /* We're resolving a call from a type */
10125 {
10127 {
10128 parse_error_context
10133 PATCH_METHOD_RETURN_ERROR ();
10134 }
10136 {
10138 parse_error_context
10144 PATCH_METHOD_RETURN_ERROR ();
10145 }
10146 }
10147 else
10153 /* IDENTIFIER_WFL will be used to report any problem further */
10155 }
10156 /* Resolution of simple names, names generated after a primary: or
10157 constructors */
10158 else
10159 {
10163 /* We search constructor in their target class */
10165 {
10169 this_identifier_node)
10172 super_identifier_node)
10173 {
10176 class_to_search =
10178 else
10179 {
10181 PATCH_METHOD_RETURN_ERROR ();
10182 }
10183 }
10185 /* Class to search is NULL if we're searching the current one */
10187 {
10191 {
10192 parse_error_context
10195 PATCH_METHOD_RETURN_ERROR ();
10196 }
10198 /* Can't instantiate an abstract class, but we can
10199 invoke it's constructor. It's use within the `new'
10200 context is denied here. */
10203 {
10204 parse_error_context
10207 PATCH_METHOD_RETURN_ERROR ();
10208 }
10211 }
10212 else
10215 }
10216 /* This is a regular search in the local class, unless an
10217 alternate class is specified. */
10218 else
10219 {
10224 else
10225 {
10228 for (;;)
10229 {
10231 break;
10233 {
10237 PATCH_METHOD_RETURN_ERROR ();
10238 }
10239 class_to_search
10241 }
10242 }
10244 }
10246 /* NAME is a simple identifier or comes from a primary. Search
10247 in the class whose declaration contain the method being
10248 invoked. */
10252 /* Don't continue if no method were found, as the next statement
10253 can't be executed then. */
10255 PATCH_METHOD_RETURN_ERROR ();
10261 /* Check for static reference if non static methods */
10264 PATCH_METHOD_RETURN_ERROR ();
10266 /* Check for inner classes creation from illegal contexts */
10270 {
10271 parse_error_context
10276 PATCH_METHOD_RETURN_ERROR ();
10277 }
10279 /* Non static methods are called with the current object extra
10280 argument. If patch a `new TYPE()', the argument is the value
10281 returned by the object allocator. If method is resolved as a
10282 primary, use the primary otherwise use the current THIS. */
10285 {
10288 /* If we're using an access method, things are different.
10289 There are two familly of cases:
10291 1) We're not generating bytecodes:
10293 - LIST is non static. It's invocation is transformed from
10294 x(a1,...,an) into this$<n>.x(a1,....an).
10295 - LIST is static. It's invocation is transformed from
10296 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10298 2) We're generating bytecodes:
10300 - LIST is non static. It's invocation is transformed from
10301 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10302 - LIST is static. It's invocation is transformed from
10303 x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10305 Of course, this$<n> can be abitrary complex, ranging from
10306 this$0 (the immediate outer context) to
10307 access$0(access$0(...(this$0))).
10309 maybe_use_access_method returns a non zero value if the
10310 this_arg has to be moved into the (then generated) stub
10311 argument list. In the meantime, the selected function
10312 might have be replaced by a generated stub. */
10315 {
10318 }
10319 }
10320 }
10322 /* Merge point of all resolution schemes. If we have nothing, this
10323 is an error, already signaled */
10325 PATCH_METHOD_RETURN_ERROR ();
10327 /* Check accessibility, position the is_static flag, build and
10328 return the call */
10332 /* Calls to clone() on array types are permitted as a special-case. */
10334 {
10344 /* FIXME: WFL yields the wrong message here but I don't know
10345 what else to use. */
10349 PATCH_METHOD_RETURN_ERROR ();
10350 }
10352 /* Deprecation check: check whether the method being invoked or the
10353 instance-being-created's type are deprecated. */
10356 else
10359 /* If invoking a innerclass constructor, there are hidden parameters
10360 to pass */
10363 {
10364 /* And make sure we add the accessed local variables to be saved
10365 in field aliases. */
10366 args = build_alias_initializer_parameter_list
10369 /* Secretly pass the current_this/primary as a second argument */
10371 {
10372 tree extra_arg;
10373 tree this_type = (current_this ?
10375 /* Method's (list) enclosing context */
10377 /* If we have a primary, use it. */
10380 /* The current `this' is an inner class but isn't a direct
10381 enclosing context for the inner class we're trying to
10382 create. Build an access to the proper enclosing context
10383 and use it. */
10386 {
10391 }
10392 /* Otherwise, just use the current `this' as an enclosing
10393 context. */
10394 else
10397 }
10398 else
10400 }
10402 /* This handles the situation where a constructor invocation needs
10403 to have an enclosing context passed as a second parameter (the
10404 constructor is one of an inner class. We extract it from the
10405 current function. */
10406 if ((is_super_init ||
10409 {
10411 tree extra_arg;
10414 {
10417 }
10418 else
10419 {
10421 extra_arg =
10424 }
10426 }
10432 /* In the context of an explicit constructor invocation, we can't
10433 invoke any method relying on `this'. Exceptions are: we're
10434 invoking a static function, primary exists and is not the current
10435 this, we're creating a new object. */
10437 && !is_static_flag
10440 {
10441 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10442 PATCH_METHOD_RETURN_ERROR ();
10443 }
10444 java_parser_context_restore_global ();
10447 /* Sometimes, we want the decl of the selected method. Such as for
10448 EH checking */
10453 /* Now is a good time to insert the call to finit$ */
10455 {
10458 /* Prepare to pass hidden parameters to finit$, if any. */
10459 finit_parms = build_alias_initializer_parameter_list
10462 finit_call =
10464 finit_parms);
10466 /* Generate the code used to initialize fields declared with an
10467 initialization statement and build a compound statement along
10468 with the super constructor invocation. */
10472 }
10473 return patch;
10474 }
10476 /* Check that we're not trying to do a static reference to a method in
10477 non static method. Return 1 if it's the case, 0 otherwise. */
10479 static int
10482 {
10485 {
10487 parse_error_context
10493 }
10495 }
10497 /* Fix the invocation of *MDECL if necessary in the case of a
10498 invocation from an inner class. *THIS_ARG might be modified
10499 appropriately and an alternative access to *MDECL might be
10500 returned. */
10502 static int
10506 {
10507 tree ctx;
10512 if (is_super_init
10519 /* If we're calling a method found in an enclosing class, generate
10520 what it takes to retrieve the right this. Don't do that if we're
10521 invoking a static method. Note that if MD's type is unrelated to
10522 CURRENT_CLASS, then the current this can be used. */
10525 {
10528 {
10531 }
10532 else
10533 {
10536 {
10539 {
10541 break;
10542 }
10545 }
10546 }
10548 }
10550 /* We might have to use an access method to get to MD. We can
10551 break the method access rule as far as we're not generating
10552 bytecode */
10554 {
10557 }
10562 /* Returnin a non zero value indicates we were doing a non static
10563 method invokation that is now a static invocation. It will have
10564 callee displace `this' to insert it in the regular argument
10565 list. */
10567 }
10569 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10570 mode. */
10572 static tree
10575 {
10580 /* Last step for args: convert build-in types. If we're dealing with
10581 a new TYPE() type call, the first argument to the constructor
10582 isn't found in the incoming argument list, but delivered by
10583 `new' */
10593 /* Resolve unresolved returned type isses */
10600 else
10601 {
10604 {
10605 case INVOKE_VIRTUAL:
10608 break;
10610 case INVOKE_NONVIRTUAL:
10611 /* If the object for the method call is null, we throw an
10612 exception. We don't do this if the object is the current
10613 method's `this'. In other cases we just rely on an
10614 optimization pass to eliminate redundant checks. */
10616 {
10617 /* We use a save_expr here to make sure we only evaluate
10618 the new `self' expression once. */
10622 }
10623 /* Fall through. */
10625 case INVOKE_SUPER:
10626 case INVOKE_STATIC:
10630 break;
10632 case INVOKE_INTERFACE:
10635 break;
10637 default:
10638 abort ();
10639 }
10641 /* Ensure self_type is initialized, (invokestatic). FIXME */
10643 }
10650 /* We're processing a `new TYPE ()' form. New is called and its
10651 returned value is the first argument to the constructor. We build
10652 a COMPOUND_EXPR and use saved expression so that the overall NEW
10653 expression value is a pointer to a newly created and initialized
10654 class. */
10656 {
10660 {
10662 return patch;
10663 }
10672 NULL_TREE);
10679 }
10681 /* If CHECK is set, then we are building a check to see if the object
10682 is NULL. */
10684 {
10687 }
10689 /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10690 put it as the first expression of a COMPOUND_EXPR. The second
10691 expression being an empty statement to be later patched if
10692 necessary. We remember a TREE_LIST (the PURPOSE is the method,
10693 the VALUE is the compound) in a hashtable and return a
10694 COMPOUND_EXPR built so that the result of the evaluation of the
10695 original PATCH node is returned. */
10698 {
10699 tree list;
10711 }
10713 return patch;
10714 }
10716 static int
10718 tree method;
10720 {
10724 return INVOKE_SUPER;
10727 return INVOKE_STATIC;
10729 /* We have to look for a constructor before we handle nonvirtual
10730 calls; otherwise the constructor will look nonvirtual. */
10732 return INVOKE_STATIC;
10735 return INVOKE_NONVIRTUAL;
10738 return INVOKE_NONVIRTUAL;
10741 return INVOKE_INTERFACE;
10743 return INVOKE_VIRTUAL;
10744 }
10746 /* Retrieve a refined list of matching methods. It covers the step
10747 15.11.2 (Compile-Time Step 2) */
10749 static tree
10752 tree cl;
10754 {
10760 /* Fix the arguments */
10762 {
10764 /* Non primitive type may have to be resolved */
10767 /* And promoted */
10771 }
10773 /* Presto. If we're dealing with an anonymous class and a
10774 constructor call, generate the right constructor now, since we
10775 know the arguments' types. */
10780 /* Find all candidates and then refine the list, searching for the
10781 most specific method. */
10787 /* Issue an error. List candidates if any. Candidates are listed
10788 only if accessible (non accessible methods may end-up here for
10789 the sake of a better error report). */
10792 {
10793 tree current;
10796 {
10800 continue;
10801 sprintf
10807 }
10810 }
10811 /* Issue the error message */
10822 return NULL_TREE;
10823 }
10825 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10826 when we're looking for a constructor. */
10828 static tree
10832 {
10837 /* Check the hash table to determine if this class has been searched
10838 already. */
10840 {
10843 return NULL;
10844 }
10845 else
10846 {
10848 java_hash_compare_tree_node);
10850 }
10852 search_not_done++;
10857 {
10860 }
10862 /* Search interfaces */
10865 {
10872 {
10874 tree rlist;
10877 arglist);
10879 }
10880 }
10881 /* Search classes */
10882 else
10883 {
10887 /* When looking finit$, class$ or instinit$, we turn LC to 1 so
10888 that we only search in class. Note that we should have found
10889 something at this point. */
10891 {
10894 abort ();
10895 }
10897 /* We must search all interfaces of this class */
10899 {
10903 {
10906 {
10907 tree rlist
10911 }
10912 }
10913 }
10915 /* Search superclass */
10917 {
10918 tree rlist;
10923 }
10924 }
10926 search_not_done--;
10928 /* We're done. Reset the searched classes list and finally search
10929 java.lang.Object if it wasn't searched already. */
10931 {
10932 if (!lc
10937 {
10941 }
10944 }
10946 /* Either return the list obtained or all selected (but
10947 inaccessible) methods for better error report. */
10949 }
10951 /* Effectively search for the appropriate method in method */
10953 static void
10958 {
10960 {
10961 /* When dealing with constructor, stop here, otherwise search
10962 other classes */
10964 continue;
10967 continue;
10970 {
10971 /* Retain accessible methods only */
10975 else
10976 /* Also retain all selected method here */
10978 }
10979 }
10980 }
10982 /* 15.11.2.2 Choose the Most Specific Method */
10984 static tree
10986 tree list;
10987 {
10992 {
10993 tree method;
10997 {
10999 /* Don't test a method against itself */
11001 continue;
11006 /* Compare arguments and location where methods where declared */
11008 {
11009 if (valid_method_invocation_conversion_p
11014 {
11018 }
11019 }
11020 }
11021 }
11023 /* Review the list and select the maximally specific methods */
11027 {
11030 candidates++;
11031 }
11033 /* If we have several and they're all abstract, just pick the
11034 closest one. */
11036 {
11039 }
11041 /* We have several (we couldn't find a most specific), all but one
11042 are abstract, we pick the only non abstract one. */
11044 {
11047 {
11050 }
11051 }
11053 /* If we can't find one, lower expectations and try to gather multiple
11054 maximally specific methods */
11056 {
11058 {
11061 }
11062 }
11064 return new_list;
11065 }
11067 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11068 converted by method invocation conversion (5.3) to the type of the
11069 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11070 to change less often than M1. */
11072 static int
11075 {
11082 /* Register M2_ARG_VALUE and M2_ARG_CACHE with the garbage
11083 collector. */
11085 {
11089 }
11095 else
11096 {
11097 /* M2_OR_ARGLIST can be a function DECL or a raw list of
11098 argument types */
11100 {
11104 }
11105 else
11110 }
11113 {
11117 break;
11120 }
11122 }
11124 /* Qualification routines */
11126 static void
11128 tree id;
11129 {
11131 saved_current_class;
11135 /* We first qualify the first element, then derive qualification of
11136 others based on the first one. If the first element is qualified
11137 by a resolution (field or type), this resolution is stored in the
11138 QUAL_RESOLUTION of the qual element being examined. We need to
11139 save the current_class since the use of SUPER might change the
11140 its value. */
11143 do {
11145 /* Simple qualified expression feature a qual_wfl that is a
11146 WFL. Expression derived from a primary feature more complicated
11147 things like a CALL_EXPR. Expression from primary need to be
11148 worked out to extract the part on which the qualification will
11149 take place. */
11152 {
11153 case CALL_EXPR:
11156 {
11159 }
11160 break;
11161 case NEW_ARRAY_EXPR:
11162 case NEW_ANONYMOUS_ARRAY_EXPR:
11165 continue;
11166 case CONVERT_EXPR:
11167 break;
11168 case NEW_CLASS_EXPR:
11170 break;
11171 case ARRAY_REF:
11174 break;
11175 case STRING_CST:
11178 break;
11179 case CLASS_LITERAL:
11182 break;
11183 default:
11184 /* Fix for -Wall. Just break doing nothing */
11185 break;
11186 }
11192 /* Pos evaluation: non WFL leading expression nodes */
11213 {
11217 }
11218 else
11219 {
11222 {
11225 }
11226 }
11228 /* If we have a THIS (from a primary), we set the context accordingly */
11230 {
11231 /* This isn't really elegant. One more added irregularity
11232 before I start using COMPONENT_REF (hopefully very soon.) */
11235 EXPR_WITH_FILE_LOCATION
11237 this_identifier_node)
11238 {
11241 }
11251 }
11252 /* If we have a SUPER, we set the context accordingly */
11254 {
11256 /* Check that there is such a thing as a super class. If not,
11257 return. The error will be caught later on, during the
11258 resolution */
11260 {
11262 return;
11263 }
11265 /* Do one more interation to set things up */
11267 }
11270 /* If name appears within the scope of a local variable declaration
11271 or parameter declaration, then it is an expression name. We don't
11272 carry this test out if we're in the context of the use of SUPER
11273 or THIS */
11277 {
11280 }
11282 /* If within the class/interface NAME was found to be used there
11283 exists a (possibly inherited) field named NAME, then this is an
11284 expression name. If we saw a NEW_ARRAY_EXPR before and want to
11285 address length, it is OK. */
11288 {
11291 }
11293 /* We reclassify NAME as yielding to a type name resolution if:
11294 - NAME is a class/interface declared within the compilation
11295 unit containing NAME,
11296 - NAME is imported via a single-type-import declaration,
11297 - NAME is declared in an another compilation unit of the package
11298 of the compilation unit containing NAME,
11299 - NAME is declared by exactly on type-import-on-demand declaration
11300 of the compilation unit containing NAME.
11301 - NAME is actually a STRING_CST.
11302 This can't happen if the expression was qualified by `this.' */
11307 {
11310 }
11312 /* Method call, array references and cast are expression name */
11319 /* Check here that NAME isn't declared by more than one
11320 type-import-on-demand declaration of the compilation unit
11321 containing NAME. FIXME */
11323 /* Otherwise, NAME is reclassified as a package name */
11324 else
11327 /* Propagate the qualification accross other components of the
11328 qualified name */
11331 {
11334 else
11336 }
11338 /* Store the global qualification for the ambiguous part of ID back
11339 into ID fields */
11347 /* Restore the current class */
11349 }
11351 static int
11354 {
11361 /* Breakdown NAME into REMAINDER . IDENTIFIER */
11364 p--;
11366 /* We didn't find a '.'. Return an error */
11376 }
11378 /* Return TRUE if two classes are from the same package. */
11380 static int
11383 {
11384 tree tmp;
11385 tree pkg1;
11386 tree pkg2;
11394 /* One in empty package. */
11398 /* Both in empty package. */
11405 }
11407 /* Patch tree nodes in a function body. When a BLOCK is found, push
11408 local variable decls if present.
11409 Same as java_complete_lhs, but does resolve static finals to values. */
11411 static tree
11413 tree node;
11414 {
11419 {
11425 {
11426 /* fold_constant_for_init sometimes widen the original type
11427 of the constant (i.e. byte to int.) It's not desirable,
11428 especially if NODE is a function argument. */
11433 else
11434 return value;
11435 }
11436 else
11438 }
11439 return node;
11440 }
11442 static tree
11444 tree node;
11445 {
11447 {
11452 return node;
11453 }
11455 }
11457 /* Patch tree nodes in a function body. When a BLOCK is found, push
11458 local variable decls if present.
11459 Same as java_complete_tree, but does not resolve static finals to values. */
11461 static tree
11463 tree node;
11464 {
11468 /* CONVERT_EXPR always has its type set, even though it needs to be
11469 worked out. */
11471 return node;
11473 /* The switch block implements cases processing container nodes
11474 first. Contained nodes are always written back. Leaves come
11475 next and return a value. */
11477 {
11478 case BLOCK:
11480 /* 1- Block section.
11481 Set the local values on decl names so we can identify them
11482 faster when they're referenced. At that stage, identifiers
11483 are legal so we don't check for declaration errors. */
11485 {
11488 }
11491 else
11492 {
11497 {
11498 /* Re-order from (((A; B); C); ...; Z) to
11499 (A; (B; (C ; (...; Z)))).
11500 This makes it easier to scan the statements left-to-right
11501 without using recursion (which might overflow the stack
11502 if the block has many statements. */
11503 for (;;)
11504 {
11507 break;
11511 }
11513 }
11515 /* Now do the actual complete, without deep recursion for
11516 long blocks. */
11520 {
11525 {
11526 /* Optimization; makes it easier to detect empty bodies.
11527 Most useful for <clinit> with all-constant initializer. */
11529 continue;
11530 }
11532 error_seen++;
11534 {
11536 for (;;)
11537 {
11542 else
11543 break;
11544 }
11548 }
11550 }
11554 return error_mark_node;
11556 }
11557 /* Turn local bindings to null */
11562 break;
11564 /* 2- They are expressions but ultimately deal with statements */
11566 case THROW_EXPR:
11569 /* 14.19 A throw statement cannot complete normally. */
11573 case SYNCHRONIZED_EXPR:
11577 case TRY_EXPR:
11580 case TRY_FINALLY_EXPR:
11591 return node;
11593 case CLEANUP_POINT_EXPR:
11598 return node;
11600 case WITH_CLEANUP_EXPR:
11606 return node;
11608 case LABELED_BLOCK_EXPR:
11613 POP_LABELED_BLOCK ();
11616 {
11619 }
11622 return node;
11624 case EXIT_BLOCK_EXPR:
11625 /* We don't complete operand 1, because it's the return value of
11626 the EXIT_BLOCK_EXPR which doesn't exist it Java */
11629 case CASE_EXPR:
11632 return cn;
11634 /* First, the case expression must be constant. Values of final
11635 fields are accepted. */
11641 {
11644 }
11645 /* Accept final locals too. */
11650 {
11653 return error_mark_node;
11654 }
11658 /* It must be assignable to the type of the switch expression. */
11661 {
11663 parse_error_context
11667 return error_mark_node;
11668 }
11674 /* Multiple instance of a case label bearing the same
11675 value is checked during code generation. The case
11676 expression is allright so far. */
11683 break;
11685 case DEFAULT_EXPR:
11687 /* Only one default label is allowed per switch statement */
11689 {
11693 return error_mark_node;
11694 }
11695 else
11700 break;
11702 case SWITCH_EXPR:
11703 case LOOP_EXPR:
11705 /* Check whether the loop was enclosed in a labeled
11706 statement. If not, create one, insert the loop in it and
11707 return the node */
11710 /* Anyways, walk the body of the loop */
11713 /* Switch statement: walk the switch expression and the cases */
11714 else
11719 else
11720 {
11722 /* If we returned something different, that's because we
11723 inserted a label. Pop the label too. */
11725 {
11728 POP_LABELED_BLOCK ();
11729 }
11730 }
11731 POP_LOOP ();
11732 return nn;
11734 case EXIT_EXPR:
11738 case COND_EXPR:
11739 /* Condition */
11742 return error_mark_node;
11743 /* then-else branches */
11746 return error_mark_node;
11749 return error_mark_node;
11751 break;
11753 case CONDITIONAL_EXPR:
11754 /* Condition */
11763 /* 3- Expression section */
11764 case COMPOUND_EXPR:
11770 else
11771 {
11773 {
11774 /* An unreachable condition in a do-while statement
11775 is *not* (technically) an unreachable statement. */
11780 {
11783 }
11784 }
11787 return error_mark_node;
11790 }
11792 break;
11794 case RETURN_EXPR:
11795 /* CAN_COMPLETE_NORMALLY (node) = 0; */
11798 case EXPR_WITH_FILE_LOCATION:
11801 {
11805 return node;
11806 /* Keep line number information somewhere were it doesn't
11807 disrupt the completion process. */
11809 {
11812 }
11814 }
11815 else
11816 {
11817 tree body;
11826 {
11827 /* Makes it easier to constant fold, detect empty bodies. */
11828 return body;
11829 }
11831 {
11832 /* Its important for the evaluation of assignment that
11833 this mark on the TREE_TYPE is propagated. */
11835 return error_mark_node;
11836 }
11837 else
11840 }
11841 break;
11843 case NEW_ARRAY_EXPR:
11844 /* Patch all the dimensions */
11847 {
11852 {
11854 continue;
11855 }
11856 else
11857 {
11859 /* Setup the location of the current dimension, for
11860 later error report. */
11864 }
11865 }
11866 /* They complete the array creation expression, if no errors
11867 were found. */
11869 return (flag ? error_mark_node
11872 case NEW_ANONYMOUS_ARRAY_EXPR:
11873 /* Create the array type if necessary. */
11875 {
11878 return error_mark_node;
11882 }
11886 return error_mark_node;
11888 return node;
11890 case NEW_CLASS_EXPR:
11891 case CALL_EXPR:
11892 /* Complete function's argument(s) first */
11894 return error_mark_node;
11895 else
11896 {
11900 super_identifier_node);
11905 return error_mark_node;
11908 /* If we call this(...), register signature and positions */
11915 }
11917 case MODIFY_EXPR:
11918 /* Save potential wfls */
11925 {
11926 tree value;
11930 /* When we have a primitype type, or a string and we're not
11931 emitting a class file, we actually don't want to generate
11932 anything for the assignment. */
11937 {
11938 /* Prepare node for patch_assignment */
11940 /* Call patch assignment to verify the assignment */
11942 return error_mark_node;
11943 /* Set DECL_INITIAL properly (a conversion might have
11944 been decided by patch_assignment) and return the
11945 empty statement. */
11946 else
11947 {
11951 else
11953 return empty_stmt_node;
11954 }
11955 }
11960 }
11964 return error_mark_node;
11968 {
11969 /* This might break when accessing outer field from inner
11970 class. TESTME, FIXME */
11973 /* Hand stabilize the lhs on both places */
11978 /* 15.25.2.a: Left hand is not an array access. FIXME */
11979 /* Now complete the RHS. We write it back later on. */
11985 /* The last part of the rewrite for E1 op= E2 is to have
11986 E1 = (T)(E1 op E2), with T being the type of E1. */
11990 /* If the assignment is compound and has reference type,
11991 then ensure the LHS has type String and nothing else. */
11998 /* 15.25.2.b: Left hand is an array access. FIXME */
11999 }
12001 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12002 function to complete this RHS. Note that a NEW_ARRAY_INIT
12003 might have been already fully expanded if created as a result
12004 of processing an anonymous array initializer. We avoid doing
12005 the operation twice by testing whether the node already bears
12006 a type. */
12010 /* Otherwise we simply complete the RHS */
12011 else
12015 return error_mark_node;
12017 /* Write back the RHS as we evaluated it. */
12020 /* In case we're handling = with a String as a RHS, we need to
12021 produce a String out of the RHS (it might still be a
12022 STRING_CST or a StringBuffer at this stage */
12028 {
12029 /* We return error_mark_node if outer_field_access_fix
12030 detects we write into a final. */
12032 return error_mark_node;
12034 }
12035 else
12036 {
12037 /* Can't assign to a (blank) final. */
12039 return error_mark_node;
12041 /* Reorganize the tree if necessary. */
12045 }
12047 /* Seek to set DECL_INITIAL to a proper value, since it might have
12048 undergone a conversion in patch_assignment. We do that only when
12049 it's necessary to have DECL_INITIAL properly set. */
12059 return node;
12061 case MULT_EXPR:
12062 case PLUS_EXPR:
12063 case MINUS_EXPR:
12064 case LSHIFT_EXPR:
12065 case RSHIFT_EXPR:
12066 case URSHIFT_EXPR:
12067 case BIT_AND_EXPR:
12068 case BIT_XOR_EXPR:
12069 case BIT_IOR_EXPR:
12070 case TRUNC_MOD_EXPR:
12071 case TRUNC_DIV_EXPR:
12072 case RDIV_EXPR:
12073 case TRUTH_ANDIF_EXPR:
12074 case TRUTH_ORIF_EXPR:
12075 case EQ_EXPR:
12076 case NE_EXPR:
12077 case GT_EXPR:
12078 case GE_EXPR:
12079 case LT_EXPR:
12080 case LE_EXPR:
12081 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12082 knows how to handle those cases. */
12087 /* Don't complete string nodes if dealing with the PLUS operand. */
12089 {
12092 return error_mark_node;
12095 }
12097 {
12100 return error_mark_node;
12103 }
12106 case INSTANCEOF_EXPR:
12110 {
12112 return node;
12113 }
12116 case UNARY_PLUS_EXPR:
12117 case NEGATE_EXPR:
12118 case TRUTH_NOT_EXPR:
12119 case BIT_NOT_EXPR:
12120 case PREDECREMENT_EXPR:
12121 case PREINCREMENT_EXPR:
12122 case POSTDECREMENT_EXPR:
12123 case POSTINCREMENT_EXPR:
12124 case CONVERT_EXPR:
12125 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12126 how to handle those cases. */
12131 return error_mark_node;
12134 break;
12136 case ARRAY_REF:
12137 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12138 how to handle those cases. */
12142 return error_mark_node;
12145 /* The same applies to wfl_op2 */
12149 return error_mark_node;
12154 case RECORD_TYPE:
12155 return node;;
12157 case COMPONENT_REF:
12158 /* The first step in the re-write of qualified name handling. FIXME.
12159 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12162 {
12166 {
12168 return error_mark_node;
12169 }
12171 {
12173 return error_mark_node;
12174 }
12175 return field;
12176 }
12177 else
12178 abort ();
12179 break;
12181 case THIS_EXPR:
12182 /* Can't use THIS in a static environment */
12184 {
12189 return error_mark_node;
12190 }
12192 {
12194 parse_error_context
12195 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12197 return error_mark_node;
12198 }
12199 return current_this;
12201 case CLASS_LITERAL:
12205 return error_mark_node;
12206 break;
12208 default:
12210 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12211 and it's time to turn it into the appropriate String object */
12214 else
12216 }
12217 return node;
12218 }
12220 /* Complete function call's argument. Return a non zero value is an
12221 error was found. */
12223 static int
12225 tree node;
12226 {
12228 tree cn;
12232 {
12237 {
12239 continue;
12240 }
12241 /* If have a string literal that we haven't transformed yet or a
12242 crafted string buffer, as a result of use of the the String
12243 `+' operator. Build `parm.toString()' and expand it. */
12246 /* Inline PRIMTYPE.TYPE read access */
12250 }
12252 return flag;
12253 }
12255 /* Sometimes (for loops and variable initialized during their
12256 declaration), we want to wrap a statement around a WFL and turn it
12257 debugable. */
12259 static tree
12262 tree stmt;
12263 {
12265 {
12268 }
12270 return stmt;
12271 }
12273 static tree
12276 {
12283 return node;
12284 }
12286 /* Create a new function block and link it approriately to current
12287 function block chain */
12289 static tree
12290 enter_block ()
12291 {
12294 /* Link block B supercontext to the previous block. The current
12295 function DECL is used as supercontext when enter_a_block is called
12296 for the first time for a given function. The current function body
12297 (DECL_FUNCTION_BODY) is set to be block B. */
12304 }
12307 {
12310 }
12311 else
12312 {
12315 }
12316 return b;
12317 }
12319 /* Exit a block by changing the current function body
12320 (DECL_FUNCTION_BODY) to the current block super context, only if
12321 the block being exited isn't the method's top level one. */
12323 static tree
12324 exit_block ()
12325 {
12326 tree b;
12328 {
12332 }
12333 else
12334 {
12339 }
12340 return b;
12341 }
12343 /* Lookup for NAME in the nested function's blocks, all the way up to
12344 the current toplevel one. It complies with Java's local variable
12345 scoping rules. */
12347 static tree
12349 tree name;
12350 {
12354 {
12355 tree current;
12357 /* Paranoid sanity check. To be removed */
12359 abort ();
12364 return current;
12366 }
12367 return NULL_TREE;
12368 }
12370 static void
12371 maybe_absorb_scoping_blocks ()
12372 {
12374 {
12378 }
12379 }
12381 \f
12382 /* This section of the source is reserved to build_* functions that
12383 are building incomplete tree nodes and the patch_* functions that
12384 are completing them. */
12386 /* Wrap a non WFL node around a WFL. */
12388 static tree
12390 tree node;
12392 {
12395 /* We want to process THIS . xxx symbolicaly, to keep it consistent
12396 with the way we're processing SUPER. A THIS from a primary as a
12397 different form than a SUPER. Turn THIS into something symbolic */
12400 else
12405 return wfl;
12406 }
12408 /* Build a super() constructor invocation. Returns empty_stmt_node if
12409 we're currently dealing with the class java.lang.Object. */
12411 static tree
12413 tree mdecl;
12414 {
12416 return empty_stmt_node;
12417 else
12418 {
12421 /* If we're dealing with an anonymous class, pass the arguments
12422 of the crafted constructor along. */
12424 {
12428 }
12430 }
12431 }
12433 /* Build a SUPER/THIS qualified method invocation. */
12435 static tree
12440 {
12441 tree invok;
12442 tree wfl =
12447 }
12449 /* Build an incomplete CALL_EXPR node. */
12451 static tree
12453 tree name;
12454 tree args;
12455 {
12459 return call;
12460 }
12462 /* Build an incomplete new xxx(...) node. */
12464 static tree
12467 {
12471 return call;
12472 }
12474 /* Build an incomplete assignment expression. */
12476 static tree
12480 {
12481 tree assignment;
12482 /* Build the corresponding binop if we deal with a Compound
12483 Assignment operator. Mark the binop sub-tree as part of a
12484 Compound Assignment expression */
12486 {
12489 }
12493 return assignment;
12494 }
12496 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
12500 tree node;
12501 {
12511 {
12515 }
12516 else
12520 return buffer;
12521 }
12523 \f
12525 /* This section of the code handle assignment check with FINAL
12526 variables. */
12528 static void
12530 tree class;
12531 {
12532 tree field;
12536 }
12538 /* Figure whether all final static variable have been initialized. */
12540 static void
12542 tree class;
12543 {
12544 tree field;
12549 parse_error_context
12553 }
12555 /* This function marks all final variable locally unassigned. */
12557 static void
12559 tree class;
12560 {
12561 tree field;
12565 }
12567 /* Figure whether all final variables have beem initialized in MDECL
12568 and mark MDECL accordingly. */
12570 static void
12572 tree class;
12573 tree mdecl;
12574 {
12575 tree field;
12580 return;
12582 /* First find out whether all final variables or no final variable
12583 are initialized in this ctor. We don't take into account final
12584 variable that have been initialized upon declaration. */
12587 {
12589 initialized++;
12590 else
12591 non_initialized++;
12592 }
12594 /* There were no non initialized variable and no initialized variable.
12595 This ctor is fine. */
12598 /* If no variables have been initialized, that fine. We'll check
12599 later whether this ctor calls a constructor which initializes
12600 them. We mark the ctor as not initializing all its finals. */
12603 /* If we have a mixed bag, then we have a problem. We need to report
12604 all the variables we're not initializing. */
12606 {
12611 {
12612 parse_error_context
12617 }
12618 }
12619 /* Otherwise we know this ctor is initializing all its final
12620 variable. We mark it so. */
12621 else
12623 }
12625 /* This function recurses in a simple what through STMT and stops when
12626 it finds a constructor call. It then verifies that the called
12627 constructor initialized its final properly. Return 1 upon success,
12628 0 or -1 otherwise. */
12630 static int
12632 tree stmt;
12633 {
12636 {
12637 case EXPR_WITH_FILE_LOCATION:
12639 case COMPOUND_EXPR:
12642 return res;
12644 case SAVE_EXPR:
12646 case CALL_EXPR:
12647 {
12649 tree fbody;
12654 abort ();
12664 }
12665 default:
12666 break;
12667 }
12669 }
12671 /* This is the last chance to catch a final variable initialization
12672 problem. This routine will report an error if a final variable was
12673 never (globally) initialized and never reported as not having been
12674 initialized properly. */
12676 static void
12678 tree class;
12679 {
12684 /* We go through all natural ctors and see whether they're
12685 initializing all their final variables or not. */
12689 {
12691 {
12692 /* It doesn't. Maybe it calls a constructor that initializes
12693 them. find out. */
12696 continue;
12699 {
12701 nnctor++;
12702 }
12703 else
12704 {
12705 parse_error_context
12709 }
12710 }
12711 else
12712 nnctor++;
12713 }
12715 /* Finally we catch final variables that never were initialized */
12718 /* If the field wasn't initialized upon declaration */
12720 /* There wasn't a natural ctor in which the field could have been
12721 initialized or we found an error looking for one. */
12723 /* If we never reported a problem with this field */
12725 {
12727 parse_error_context
12731 }
12732 }
12734 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12735 context. */
12737 static int
12740 {
12751 /* Now the logic. We can modify a final VARIABLE:
12752 1) in finit$, (its declaration was followed by an initialization,)
12753 2) consistently in each natural ctor, if it wasn't initialized in
12754 finit$ or once in <clinit>. In any other cases, an error should be
12755 reported. */
12757 {
12760 }
12763 /* Only if it wasn't given a value upon initialization */
12765 /* If it was never assigned a value in this constructor */
12767 {
12768 /* Turn the locally assigned flag on, it will be checked later
12769 on to point out at discrepancies. */
12774 }
12776 /* Other problems should be reported right away. */
12777 parse_error_context
12782 /* Note that static field can be initialized once and only once. */
12787 }
12789 /* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
12790 read. This is needed to avoid circularities in the implementation
12791 of these fields in libjava. */
12793 static tree
12796 {
12800 {
12807 {
12811 }
12812 }
12814 }
12816 /* 15.25 Assignment operators. */
12818 static tree
12820 tree node;
12821 tree wfl_op1;
12822 tree wfl_op2;
12823 {
12832 /* Lhs can be a named variable */
12834 {
12836 }
12837 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
12838 comment on reason why */
12840 {
12843 }
12844 /* Or a field access */
12847 /* Or a function return slot */
12850 /* Otherwise, we might want to try to write into an optimized static
12851 final, this is an of a different nature, reported further on. */
12854 {
12856 {
12857 /* What we should do instead is resetting the all the flags
12858 previously set, exchange lvalue for llvalue and continue. */
12860 return error_mark_node;
12861 }
12862 else
12864 }
12865 else
12866 {
12869 }
12872 /* 5.1 Try the assignment conversion for builtin type. */
12875 /* 5.2 If it failed, try a reference conversion */
12879 /* 15.25.2 If we have a compound assignment, convert RHS into the
12880 type of the LHS */
12884 /* Explicit cast required. This is an error */
12886 {
12889 tree wfl;
12892 /* If the assignment is part of a declaration, we use the WFL of
12893 the declared variable to point out the error and call it a
12894 declaration problem. If the assignment is a genuine =
12895 operator, we call is a operator `=' problem, otherwise we
12896 call it an assignment problem. In both of these last cases,
12897 we use the WFL of the operator to indicate the error. */
12900 {
12903 }
12904 else
12905 {
12911 else
12913 }
12916 parse_error_context
12919 else
12920 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12924 }
12926 /* Inline read access to java.lang.PRIMTYPE.TYPE */
12931 return error_mark_node;
12933 /* 10.10: Array Store Exception runtime check */
12934 if (!flag_emit_class_files
12935 && !flag_emit_xref
12936 && lvalue_from_array
12938 {
12939 tree check;
12942 /* We need to retrieve the right argument for
12943 _Jv_CheckArrayStore. This is somewhat complicated by bounds
12944 and null pointer checks, both of which wrap the operand in
12945 one layer of COMPOUND_EXPR. */
12948 else
12949 {
12952 /* We can have a SAVE_EXPR here when doing String +=. */
12957 else
12959 }
12961 /* Build the invocation of _Jv_CheckArrayStore */
12967 NULL_TREE);
12970 /* We have to decide on an insertion point */
12972 {
12973 tree t;
12975 {
12979 }
12980 else
12983 }
12985 {
12991 {
12994 }
12996 /* Find the array bound check, hook the original array access. */
13000 /* Make sure the bound check will happen before the store check */
13001 new_compound =
13004 /* Re-assemble the augmented array access. */
13006 }
13007 else
13009 }
13011 /* Final locals can be used as case values in switch
13012 statement. Prepare them for this eventuality. */
13018 )
13019 {
13022 }
13027 return node;
13028 }
13030 /* Check that type SOURCE can be cast into type DEST. If the cast
13031 can't occur at all, return 0 otherwise 1. This function is used to
13032 produce accurate error messages on the reasons why an assignment
13033 failed. */
13035 static tree
13038 {
13043 {
13044 /* `null' may be assigned to any reference type */
13047 /* Try the reference assignment conversion */
13050 /* This is a magic assignment that we process differently */
13053 }
13054 return new_rhs;
13055 }
13057 /* Check that RHS can be converted into LHS_TYPE by the assignment
13058 conversion (5.2), for the cases of RHS being a builtin type. Return
13059 NULL_TREE if the conversion fails or if because RHS isn't of a
13060 builtin type. Return a converted RHS if the conversion is possible. */
13062 static tree
13065 {
13069 /* Handle boolean specially. */
13072 {
13076 }
13078 /* Zero accepted everywhere */
13084 /* 5.1.1 Try Identity Conversion,
13085 5.1.2 Try Widening Primitive Conversion */
13089 /* Try a narrowing primitive conversion (5.1.3):
13090 - expression is a constant expression of type int AND
13091 - variable is byte, short or char AND
13092 - The value of the expression is representable in the type of the
13093 variable */
13097 {
13101 parse_warning_context
13104 /* Reported a warning that will turn into an error further
13105 down, so we don't return */
13106 }
13108 return new_rhs;
13109 }
13111 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
13112 conversion (5.1.1) or widening primitive conversion (5.1.2). Return
13113 0 is the conversion test fails. This implements parts the method
13114 invocation convertion (5.3). */
13116 static int
13119 {
13120 /* 5.1.1: This is the identity conversion part. */
13124 /* Reject non primitive types and boolean conversions. */
13128 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13129 than a char can't be converted into a char. Short can't too, but
13130 the < test below takes care of that */
13134 /* Accept all promoted type here. Note, we can't use <= in the test
13135 below, because we still need to bounce out assignments of short
13136 to char and the likes */
13139 || rhs_type == promoted_short_type_node
13140 || rhs_type == promoted_char_type_node
13144 /* From here, an integral is widened if its precision is smaller
13145 than the precision of the LHS or if the LHS is a floating point
13146 type, or the RHS is a float and the RHS a double. */
13154 }
13156 /* Check that something of SOURCE type can be assigned or cast to
13157 something of DEST type at runtime. Return 1 if the operation is
13158 valid, 0 otherwise. If CAST is set to 1, we're treating the case
13159 were SOURCE is cast into DEST, which borrows a lot of the
13160 assignment check. */
13162 static int
13164 tree source;
13165 tree dest;
13167 {
13168 /* SOURCE or DEST might be null if not from a declared entity. */
13178 /* If source and dest are being compiled from bytecode, they may need to
13179 be loaded. */
13181 {
13184 }
13186 {
13189 }
13191 /* Case where SOURCE is a class type */
13193 {
13199 {
13200 /* If doing a cast and SOURCE is final, the operation is
13201 always correct a compile time (because even if SOURCE
13202 does not implement DEST, a subclass of SOURCE might). */
13205 /* Otherwise, SOURCE must implement DEST */
13207 }
13208 /* DEST is an array, cast permited if SOURCE is of Object type */
13210 }
13212 {
13214 {
13215 /* If not casting, DEST must be the Object type */
13218 /* We're doing a cast. The cast is always valid is class
13219 DEST is not final, otherwise, DEST must implement SOURCE */
13222 else
13224 }
13226 {
13227 /* If doing a cast, then if SOURCE and DEST contain method
13228 with the same signature but different return type, then
13229 this is a (compile time) error */
13231 {
13233 tree source_type;
13234 tree source_sig;
13235 tree source_name;
13238 {
13239 source_sig =
13250 }
13252 }
13253 else
13255 }
13256 else
13257 {
13258 /* Array */
13259 return (cast
13263 }
13264 }
13266 {
13269 /* Can't cast an array to an interface unless the interface is
13270 java.lang.Cloneable or java.io.Serializable. */
13274 else /* Arrays */
13275 {
13279 /* In case of severe errors, they turn out null */
13286 }
13288 }
13290 }
13292 static int
13294 tree source;
13295 tree dest;
13296 {
13313 }
13315 static tree
13317 tree arg;
13318 {
13323 return arg;
13324 }
13326 /* Return a non zero value if SOURCE can be converted into DEST using
13327 the method invocation conversion rule (5.3). */
13328 static int
13331 {
13337 }
13339 /* Build an incomplete binop expression. */
13341 static tree
13346 {
13349 /* Store the location of the operator, for better error report. The
13350 string of the operator will be rebuild based on the OP value. */
13352 return binop;
13353 }
13355 /* Build the string of the operator retained by NODE. If NODE is part
13356 of a compound expression, add an '=' at the end of the string. This
13357 function is called when an error needs to be reported on an
13358 operator. The string is returned as a pointer to a static character
13359 buffer. */
13363 tree node;
13364 {
13365 #define BUILD_OPERATOR_STRING(S) \
13366 { \
13368 return buffer; \
13369 }
13373 {
13401 default:
13404 }
13405 return NULL;
13406 #undef BUILD_OPERATOR_STRING
13407 }
13409 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
13411 static int
13414 {
13423 }
13425 /* Return a non zero value if CODE is one of the operators that can be
13426 used in conjunction with the `=' operator in a compound assignment. */
13428 static int
13431 {
13435 break;
13438 }
13440 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
13442 static tree
13444 tree t;
13445 {
13449 return t;
13455 return t;
13457 /* Now the left branch of the binary operator. */
13461 return t;
13466 return t;
13470 /* It's got to be the an equivalent decl */
13472 {
13473 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13475 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13477 /* Change the right part of the BINOP_EXPR */
13479 }
13481 return t;
13482 }
13484 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13485 errors but we modify NODE so that it contains the type computed
13486 according to the expression, when it's fixed. Otherwise, we write
13487 error_mark_node as the type. It allows us to further the analysis
13488 of remaining nodes and detects more errors in certain cases. */
13490 static tree
13492 tree node;
13493 tree wfl_op1;
13494 tree wfl_op2;
13495 {
13503 /* If 1, tell the routine that we have to return error_mark_node
13504 after checking for the initialization of the RHS */
13509 /* If either op<n>_type are NULL, this might be early signs of an
13510 error situation, unless it's too early to tell (in case we're
13511 handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13512 correctly so the error can be later on reported accurately. */
13515 {
13516 tree n;
13518 {
13521 }
13523 {
13526 }
13527 }
13530 {
13531 /* 15.16 Multiplicative operators */
13537 {
13544 break;
13545 }
13548 /* Detect integral division by zero */
13554 {
13555 parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown.");
13557 }
13559 /* Change the division operator if necessary */
13563 /* Before divisions as is disapear, try to simplify and bail if
13564 applicable, otherwise we won't perform even simple
13565 simplifications like (1-1)/3. We can't do that with floating
13566 point number, folds can't handle them at this stage. */
13569 {
13573 return node;
13574 }
13577 && flag_use_divide_subroutine
13578 && ! flag_emit_class_files
13582 /* This one is more complicated. FLOATs are processed by a
13583 function call to soft_fmod. Duplicate the value of the
13584 COMPOUND_ASSIGN_P flag. */
13586 {
13591 return mod;
13592 }
13593 break;
13595 /* 15.17 Additive Operators */
13598 /* Operation is valid if either one argument is a string
13599 constant, a String object or a StringBuffer crafted for the
13600 purpose of the a previous usage of the String concatenation
13601 operator */
13612 Numeric Types */
13614 {
13621 break;
13622 }
13624 break;
13626 /* 15.18 Shift Operators */
13627 case LSHIFT_EXPR:
13628 case RSHIFT_EXPR:
13629 case URSHIFT_EXPR:
13631 {
13634 else
13635 {
13638 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13641 else
13646 }
13649 break;
13650 }
13652 /* Unary numeric promotion (5.6.1) is performed on each operand
13653 separatly */
13657 /* The type of the shift expression is the type of the promoted
13658 type of the left-hand operand */
13661 /* Shift int only up to 0x1f and long up to 0x3f */
13665 else
13669 /* The >>> operator is a >> operating on unsigned quantities */
13671 {
13672 tree to_return;
13680 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13684 return to_return;
13685 }
13686 break;
13688 /* 15.19.1 Type Comparison Operator instaceof */
13689 case INSTANCEOF_EXPR:
13694 return error_mark_node;
13696 /* The first operand must be a reference type or the null type */
13700 /* The second operand must be a reference type */
13702 {
13704 parse_error_context
13708 }
13711 {
13712 /* If the first operand is null, the result is always false */
13714 return boolean_false_node;
13716 {
13719 return node;
13720 }
13721 /* Otherwise we have to invoke instance of to figure it out */
13722 else
13724 }
13725 /* There is no way the expression operand can be an instance of
13726 the type operand. This is a compile time error. */
13727 else
13728 {
13731 parse_error_context
13736 }
13738 break;
13740 /* 15.21 Bitwise and Logical Operators */
13741 case BIT_AND_EXPR:
13742 case BIT_XOR_EXPR:
13743 case BIT_IOR_EXPR:
13745 /* Binary numeric promotion is performed on both operand and the
13746 expression retain that type */
13751 /* The type of the bitwise operator expression is BOOLEAN */
13753 else
13754 {
13761 /* Insert a break here if adding thing before the switch's
13762 break for this case */
13763 }
13764 break;
13766 /* 15.22 Conditional-And Operator */
13767 case TRUTH_ANDIF_EXPR:
13768 /* 15.23 Conditional-Or Operator */
13769 case TRUTH_ORIF_EXPR:
13770 /* Operands must be of BOOLEAN type */
13773 {
13780 break;
13781 }
13782 /* The type of the conditional operators is BOOLEAN */
13784 break;
13786 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13787 case LT_EXPR:
13788 case GT_EXPR:
13789 case LE_EXPR:
13790 case GE_EXPR:
13791 /* The type of each of the operands must be a primitive numeric
13792 type */
13794 {
13801 break;
13802 }
13803 /* Binary numeric promotion is performed on the operands */
13805 /* The type of the relation expression is always BOOLEAN */
13807 break;
13809 /* 15.20 Equality Operator */
13810 case EQ_EXPR:
13811 case NE_EXPR:
13812 /* It's time for us to patch the strings. */
13814 {
13817 }
13819 {
13822 }
13824 /* 15.20.1 Numerical Equality Operators == and != */
13825 /* Binary numeric promotion is performed on the operands */
13829 /* 15.20.2 Boolean Equality Operators == and != */
13834 /* 15.20.3 Reference Equality Operators == and != */
13835 /* Types have to be either references or the null type. If
13836 they're references, it must be possible to convert either
13837 type to the other by casting conversion. */
13845 /* Else we have an error figure what can't be converted into
13846 what and report the error */
13847 else
13848 {
13851 parse_error_context
13859 break;
13860 }
13862 break;
13863 default:
13864 abort ();
13865 }
13868 return error_mark_node;
13876 return node;
13878 /* fold does not respect side-effect order as required for Java but not C.
13879 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13880 * bytecode.
13881 */
13885 return node;
13886 }
13888 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13889 zero value, the value of CSTE comes after the valude of STRING */
13891 static tree
13893 tree cste;
13896 {
13903 {
13906 }
13907 else
13908 {
13911 }
13914 }
13916 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13917 new STRING_CST on success, NULL_TREE on failure */
13919 static tree
13923 {
13924 /* Handle two string constants right away */
13929 /* Reasonable integer constant can be treated right away */
13931 {
13945 {
13949 }
13950 else
13954 }
13955 return NULL_TREE;
13956 }
13958 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13959 has to be a STRING_CST and the other part must be a STRING_CST or a
13960 INTEGRAL constant. Return a new STRING_CST if the operation
13961 succeed, NULL_TREE otherwise.
13963 If the case we want to optimize for space, we might want to return
13964 NULL_TREE for each invocation of this routine. FIXME */
13966 static tree
13969 {
13971 {
13979 /* Walk REST, only if it looks reasonable */
13984 {
13987 return error_mark_node;
13989 }
13991 }
13992 return NULL_TREE;
13993 }
13995 /* Implement the `+' operator. Does static optimization if possible,
13996 otherwise create (if necessary) and append elements to a
13997 StringBuffer. The StringBuffer will be carried around until it is
13998 used for a function call or an assignment. Then toString() will be
13999 called on it to turn it into a String object. */
14001 static tree
14004 {
14005 tree result;
14011 /* Try to do some static optimization */
14013 return result;
14015 /* Discard empty strings on either side of the expression */
14017 {
14020 }
14024 /* If operands are string constant, turn then into object references */
14030 /* If either one of the constant is null and the other non null
14031 operand is a String object, return it. */
14033 return op1;
14035 /* If OP1 isn't already a StringBuffer, create and
14036 initialize a new one */
14038 {
14039 /* Two solutions here:
14040 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
14041 2) OP1 is something else, we call new StringBuffer().append(OP1). */
14044 else
14045 {
14048 }
14049 }
14052 {
14053 /* OP1 is no longer the last node holding a crafted StringBuffer */
14055 /* Create a node for `{new...,xxx}.append (op2)' */
14058 }
14060 /* Mark the last node holding a crafted StringBuffer */
14064 return op1;
14065 }
14067 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
14068 StringBuffer. If no string were found to be patched, return
14069 NULL. */
14071 static tree
14073 tree node;
14074 {
14076 return error_mark_node;
14080 {
14083 tree ret;
14084 /* Temporary disable forbid the use of `this'. */
14087 /* String concatenation arguments must be evaluated in order too. */
14089 /* Restore it at its previous value */
14091 return ret;
14092 }
14093 return NULL_TREE;
14094 }
14096 /* Build the internal representation of a string constant. */
14098 static tree
14100 tree node;
14101 {
14104 {
14108 }
14111 return node;
14112 }
14114 /* Build an incomplete unary operator expression. */
14116 static tree
14119 tree op1;
14120 {
14122 tree unaryop;
14124 {
14130 }
14134 /* Store the location of the operator, for better error report. The
14135 string of the operator will be rebuild based on the OP value. */
14137 return unaryop;
14138 }
14140 /* Special case for the ++/-- operators, since they require an extra
14141 argument to build, which is set to NULL and patched
14142 later. IS_POST_P is 1 if the operator, 0 otherwise. */
14144 static tree
14147 tree op1;
14149 {
14151 {
14154 };
14158 /* Store the location of the operator, for better error report. The
14159 string of the operator will be rebuild based on the OP value. */
14161 return node;
14162 }
14164 /* Build an incomplete cast operator, based on the use of the
14165 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14166 set. java_complete_tree is trained to walk a CONVERT_EXPR even
14167 though its type is already set. */
14169 static tree
14173 {
14176 return node;
14177 }
14179 /* Build an incomplete class reference operator. */
14180 static tree
14183 tree class_name;
14184 {
14187 return node;
14188 }
14190 /* Complete an incomplete class reference operator. */
14191 static tree
14193 tree node;
14194 {
14196 tree ref_type;
14199 return error_mark_node;
14202 {
14204 /* A class referenced by `foo.class' is initialized. */
14208 }
14210 /* If we're emitting class files and we have to deal with non
14211 primitive types, we invoke (and consider generating) the
14212 synthetic static method `class$'. */
14217 }
14219 /* 15.14 Unary operators. We return error_mark_node in case of error,
14220 but preserve the type of NODE if the type is fixed. */
14222 static tree
14224 tree node;
14225 tree wfl_op;
14226 {
14237 {
14238 /* 15.13.2 Postfix Increment Operator ++ */
14239 case POSTINCREMENT_EXPR:
14240 /* 15.13.3 Postfix Increment Operator -- */
14241 case POSTDECREMENT_EXPR:
14242 /* 15.14.1 Prefix Increment Operator ++ */
14243 case PREINCREMENT_EXPR:
14244 /* 15.14.2 Prefix Decrement Operator -- */
14245 case PREDECREMENT_EXPR:
14248 /* We might be trying to change an outer field accessed using
14249 access method. */
14251 {
14252 /* Retrieve the decl of the field we're trying to access. We
14253 do that by first retrieving the function we would call to
14254 access the field. It has been already verified that this
14255 field isn't final */
14258 else
14261 }
14262 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14270 {
14271 tree lvalue;
14272 /* Before screaming, check that we're not in fact trying to
14273 increment a optimized static final access, in which case
14274 we issue an different error message. */
14282 }
14287 /* From now on, we know that op if a variable and that it has a
14288 valid wfl. We use wfl_op to locate errors related to the
14289 ++/-- operand. */
14291 {
14292 parse_error_context
14297 }
14298 else
14299 {
14300 /* Before the addition, binary numeric promotion is performed on
14301 both operands, if really necessary */
14303 {
14306 }
14307 else
14308 {
14313 }
14315 /* We remember we might be accessing an outer field */
14317 {
14318 /* We re-generate an access to the field */
14322 /* And we patch the original access$() into a write
14323 with plus_op as a rhs */
14325 }
14327 /* And write back into the node. */
14330 /* Convert the overall back into its original type, if
14331 necessary, and return */
14334 else
14336 }
14337 break;
14339 /* 15.14.3 Unary Plus Operator + */
14340 case UNARY_PLUS_EXPR:
14341 /* 15.14.4 Unary Minus Operator - */
14342 case NEGATE_EXPR:
14344 {
14348 }
14349 /* Unary numeric promotion is performed on operand */
14350 else
14351 {
14356 }
14357 break;
14359 /* 15.14.5 Bitwise Complement Operator ~ */
14360 case BIT_NOT_EXPR:
14362 {
14366 }
14367 else
14368 {
14371 }
14372 break;
14374 /* 15.14.6 Logical Complement Operator ! */
14375 case TRUTH_NOT_EXPR:
14377 {
14379 /* But the type is known. We will report an error if further
14380 attempt of a assignment is made with this rhs */
14383 }
14384 else
14386 break;
14388 /* 15.15 Cast Expression */
14389 case CONVERT_EXPR:
14392 {
14393 /* If this cast is part of an assignment, we tell the code
14394 that deals with it not to complain about a mismatch,
14395 because things have been cast, anyways */
14398 }
14399 else
14400 {
14403 return value;
14404 }
14405 break;
14406 }
14409 return error_mark_node;
14411 /* There are cases where node has been replaced by something else
14412 and we don't end up returning here: UNARY_PLUS_EXPR,
14413 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14418 }
14420 /* Generic type resolution that sometimes takes place during node
14421 patching. Returned the resolved type or generate an error
14422 message. Return the resolved type or NULL_TREE. */
14424 static tree
14426 tree type;
14427 {
14429 {
14432 {
14436 return NULL_TREE;
14437 }
14439 }
14440 return type;
14441 }
14442 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14443 found. Otherwise NODE or something meant to replace it is returned. */
14445 static tree
14447 tree node;
14448 tree wfl_op;
14449 {
14455 /* First resolve OP_TYPE if unresolved */
14457 return error_mark_node;
14459 /* Check on cast that are proven correct at compile time */
14461 {
14462 /* Same type */
14464 return node;
14466 /* float and double type are converted to the original type main
14467 variant and then to the target type. */
14471 /* Try widening/narowwing convertion. Potentially, things need
14472 to be worked out in gcc so we implement the extreme cases
14473 correctly. fold_convert() needs to be fixed. */
14475 }
14477 /* It's also valid to cast a boolean into a boolean */
14479 return node;
14481 /* null can be casted to references */
14485 /* The remaining legal casts involve conversion between reference
14486 types. Check for their compile time correctness. */
14489 {
14491 /* Now, the case can be determined correct at compile time if
14492 OP_TYPE can be converted into CAST_TYPE by assignment
14493 conversion (5.2) */
14496 {
14498 return node;
14499 }
14502 {
14504 return node;
14505 }
14507 /* The cast requires a run-time check */
14512 NULL_TREE);
14513 }
14515 /* Any other casts are proven incorrect at compile time */
14520 return error_mark_node;
14521 }
14523 /* Build a null constant and give it the type TYPE. */
14525 static tree
14527 tree type;
14528 {
14531 return node;
14532 }
14534 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14535 a list of indices. */
14536 static tree
14540 {
14543 return node;
14544 }
14546 /* 15.12 Array Access Expression */
14548 static tree
14550 tree node;
14551 {
14563 /* The array reference must be an array */
14565 {
14566 parse_error_context
14572 }
14574 /* The array index undergoes unary numeric promotion. The promoted
14575 type must be int */
14578 {
14583 else
14589 }
14592 return error_mark_node;
14597 {
14600 }
14601 else
14602 {
14603 /* The save_expr is for correct evaluation order. It would be cleaner
14604 to use force_evaluation_order (see comment there), but that is
14605 difficult when we also have to deal with bounds checking. */
14611 }
14613 return node;
14614 }
14616 /* 15.9 Array Creation Expressions */
14618 static tree
14620 tree type;
14621 tree dims;
14623 {
14624 tree node =
14627 return node;
14628 }
14630 static tree
14632 tree node;
14633 {
14641 /* Dimension types are verified. It's better for the types to be
14642 verified in order. */
14644 {
14648 /* Dim might have been saved during its evaluation */
14651 /* The type of each specified dimension must be an integral type. */
14655 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14656 promoted type must be int. */
14657 else
14658 {
14662 }
14664 /* Report errors on types here */
14666 {
14667 parse_error_context
14674 }
14677 }
14679 /* Resolve array base type if unresolved */
14684 {
14685 /* We don't want further evaluation of this bogus array creation
14686 operation */
14688 return error_mark_node;
14689 }
14691 /* Set array_type to the actual (promoted) array type of the result. */
14695 {
14697 }
14701 {
14703 array_type
14709 }
14712 /* The node is transformed into a function call. Things are done
14713 differently according to the number of dimensions. If the number
14714 of dimension is equal to 1, then the nature of the base type
14715 (primitive or not) matters. */
14719 /* Can't reuse what's already written in expr.c because it uses the
14720 JVM stack representation. Provide a build_multianewarray. FIXME */
14726 NULL_TREE);
14727 }
14729 /* 10.6 Array initializer. */
14731 /* Build a wfl for array element that don't have one, so we can
14732 pin-point errors. */
14734 static tree
14736 tree node;
14737 {
14741 else
14742 return NULL_TREE;
14743 }
14745 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14746 identification of initialized arrays easier to detect during walk
14747 and expansion. */
14749 static tree
14752 tree values;
14753 {
14757 return to_return;
14758 }
14760 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14761 occurred. Otherwise return NODE after having set its type
14762 appropriately. */
14764 static tree
14767 {
14770 HOST_WIDE_INT length;
14775 {
14779 return error_mark_node;
14780 }
14788 {
14791 {
14794 /* When compiling to native code, STRING_CST is converted to
14795 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14798 }
14799 else
14800 {
14804 }
14808 }
14811 return error_mark_node;
14813 /* Create a new type. We can't reuse the one we have here by
14814 patching its dimension because it originally is of dimension -1
14815 hence reused by gcc. This would prevent triangular arrays. */
14821 return node;
14822 }
14824 /* Verify that one entry of the initializer element list can be
14825 assigned to the array base type. Report 1 if an error occurred, 0
14826 otherwise. */
14828 static int
14831 {
14840 /* patch_string return error_mark_node if arg is error_mark_node */
14848 /* At anytime, try_builtin_assignconv can report a warning on
14849 constant overflow during narrowing. */
14855 /* Check and report errors */
14857 {
14862 parse_error_context
14866 }
14869 {
14872 }
14878 return error_seen;
14879 }
14881 static tree
14884 {
14888 return node;
14889 }
14891 /* 14.15 The return statement. It builds a modify expression that
14892 assigns the returned value to the RESULT_DECL that hold the value
14893 to be returned. */
14895 static tree
14898 tree op;
14899 {
14903 return node;
14904 }
14906 static tree
14908 tree node;
14909 {
14918 /* It's invalid to have a return value within a function that is
14919 declared with the keyword void or that is a constructor */
14923 /* It's invalid to use a return statement in a static block */
14927 /* It's invalid to have a no return value within a function that
14928 isn't declared with the keyword `void' */
14936 {
14946 {
14953 }
14954 else
14958 return error_mark_node;
14959 }
14961 /* If we have a return_exp, build a modify expression and expand
14962 it. Note: at that point, the assignment is declared valid, but we
14963 may want to carry some more hacks */
14965 {
14969 /* If the function returned value and EXP are booleans, EXP has
14970 to be converted into the type of DECL_RESULT, which is integer
14971 (see complete_start_java_method) */
14976 /* `null' can be assigned to a function returning a reference */
14989 {
14992 }
14993 else
14994 return error_mark_node;
14995 }
14998 return node;
14999 }
15001 /* 14.8 The if Statement */
15003 static tree
15007 {
15008 tree node;
15014 return node;
15015 }
15017 static tree
15019 tree node;
15020 {
15026 /* The type of expression must be boolean */
15029 {
15030 parse_error_context
15034 return error_mark_node;
15035 }
15042 return node;
15043 }
15045 /* 14.6 Labeled Statements */
15047 /* Action taken when a lableled statement is parsed. a new
15048 LABELED_BLOCK_EXPR is created. No statement is attached to the
15049 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
15051 static tree
15054 tree label;
15055 {
15056 tree label_name ;
15060 else
15061 {
15063 /* Issue an error if we try to reuse a label that was previously
15064 declared */
15066 {
15076 java_error_count--;
15077 }
15078 }
15084 return node;
15085 }
15087 /* A labeled statement LBE is attached a statement. */
15089 static tree
15092 tree statement;
15093 {
15094 /* In anyways, tie the loop to its statement */
15096 pop_labeled_block ();
15097 POP_LABELED_BLOCK ();
15098 return lbe;
15099 }
15101 /* 14.10, 14.11, 14.12 Loop Statements */
15103 /* Create an empty LOOP_EXPR and make it the last in the nested loop
15104 list. */
15106 static tree
15108 tree loop_body;
15109 {
15113 return loop;
15114 }
15116 /* Create a loop body according to the following structure:
15117 COMPOUND_EXPR
15118 COMPOUND_EXPR (loop main body)
15119 EXIT_EXPR (this order is for while/for loops.
15120 LABELED_BLOCK_EXPR the order is reversed for do loops)
15121 LABEL_DECL (a continue occuring here branches at the
15122 BODY end of this labeled block)
15123 INCREMENT (if any)
15125 REVERSED, if non zero, tells that the loop condition expr comes
15126 after the body, like in the do-while loop.
15128 To obtain a loop, the loop body structure described above is
15129 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15131 LABELED_BLOCK_EXPR
15132 LABEL_DECL (use this label to exit the loop)
15133 LOOP_EXPR
15134 <structure described above> */
15136 static tree
15139 tree condition;
15141 {
15152 return
15155 }
15157 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15158 their order) on the current loop. Unlink the current loop from the
15159 loop list. */
15161 static tree
15166 {
15170 {
15172 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15173 The real EXIT_EXPR is one operand further. */
15175 /* This one is for accurate error reports */
15178 }
15180 POP_LOOP ();
15181 return to_return;
15182 }
15184 /* Tailored version of finish_loop_body for FOR loops, when FOR
15185 loops feature the condition part */
15187 static tree
15191 {
15192 /* Put the condition and the loop body in place */
15194 /* LOOP is the current loop which has been now popped of the loop
15195 stack. Install the update block */
15197 return loop;
15198 }
15200 /* Try to find the loop a block might be related to. This comprises
15201 the case where the LOOP_EXPR is found as the second operand of a
15202 COMPOUND_EXPR, because the loop happens to have an initialization
15203 part, then expressed as the first operand of the COMPOUND_EXPR. If
15204 the search finds something, 1 is returned. Otherwise, 0 is
15205 returned. The search is assumed to start from a
15206 LABELED_BLOCK_EXPR's block. */
15208 static tree
15210 tree statement;
15211 {
15213 return statement;
15217 else
15218 return NULL_TREE;
15226 }
15228 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15229 returned otherwise. */
15231 static int
15234 {
15245 }
15247 /* If the loop isn't surrounded by a labeled statement, create one and
15248 insert LOOP as its body. */
15250 static tree
15252 tree loop;
15253 {
15254 tree loop_label;
15258 return loop;
15261 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15262 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15265 return loop_label;
15266 }
15268 /* 14.13, 14.14: break and continue Statements */
15270 /* Build a break or a continue statement. a null NAME indicates an
15271 unlabeled break/continue statement. */
15273 static tree
15276 tree name;
15277 {
15281 {
15284 /* Null means that we don't have a target for this named
15285 break/continue. In this case, we make the target to be the
15286 label name, so that the error can be reported accuratly in
15287 patch_bc_statement. */
15289 }
15290 /* Unlabeled break/continue will be handled during the
15291 break/continue patch operation */
15292 break_continue
15299 return break_continue;
15300 }
15302 /* Verification of a break/continue statement. */
15304 static tree
15306 tree node;
15307 {
15312 /* Having an identifier here means that the target is unknown. */
15314 {
15317 return error_mark_node;
15318 }
15320 {
15321 /* It's a continue statement. */
15323 {
15325 {
15329 else
15330 parse_error_context
15333 return error_mark_node;
15334 }
15339 {
15341 break;
15342 }
15343 }
15344 }
15346 {
15348 {
15350 {
15353 return error_mark_node;
15354 }
15358 {
15360 break;
15361 }
15362 }
15363 }
15368 /* Our break/continue don't return values. */
15370 /* Encapsulate the break within a compound statement so that it's
15371 expanded all the times by expand_expr (and not clobbered
15372 sometimes, like after a if statement) */
15375 return node;
15376 }
15378 /* Process the exit expression belonging to a loop. Its type must be
15379 boolean. */
15381 static tree
15383 tree node;
15384 {
15389 /* The type of expression must be boolean */
15391 {
15392 parse_error_context
15396 return error_mark_node;
15397 }
15398 /* Now we know things are allright, invert the condition, fold and
15399 return */
15412 return node;
15413 }
15415 /* 14.9 Switch statement */
15417 static tree
15419 tree node;
15420 {
15423 /* Complete the switch expression */
15426 /* The type of the switch expression must be char, byte, short or
15427 int */
15429 {
15434 /* This is what java_complete_tree will check */
15436 return error_mark_node;
15437 }
15441 /* Ready to return */
15443 {
15445 return error_mark_node;
15446 }
15452 return node;
15453 }
15455 /* 14.18 The try/catch statements */
15457 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15458 catches TYPE and executes CATCH_STMTS. */
15460 static tree
15464 {
15467 /* First build a try block */
15470 /* Build a catch block: we need a catch clause parameter */
15473 /* And a block */
15476 /* Initialize the variable and store in the block */
15481 /* Add the catch statements */
15484 /* Now we can build a CATCH_EXPR */
15488 }
15490 static tree
15494 {
15497 return node;
15498 }
15500 static tree
15504 {
15507 return node;
15508 }
15510 static tree
15512 tree node;
15513 {
15516 /* Exception handlers are considered in left to right order */
15520 /* Check catch clauses, if any. Every time we find an error, we try
15521 to process the next catch clause. We process the catch clause before
15522 the try block so that when processing the try block we can check thrown
15523 exceptions againts the caught type list. */
15525 {
15530 /* At this point, the structure of the catch clause is
15531 CATCH_EXPR (catch node)
15532 BLOCK (with the decl of the parameter)
15533 COMPOUND_EXPR
15534 MODIFY_EXPR (assignment of the catch parameter)
15535 BLOCK (catch clause block)
15536 */
15541 /* Catch clauses can't have more than one parameter declared,
15542 but it's already enforced by the grammar. Make sure that the
15543 only parameter of the clause statement in of class Throwable
15544 or a subclass of Throwable, but that was done earlier. The
15545 catch clause parameter type has also been resolved. */
15547 /* Just make sure that the catch clause parameter type inherits
15548 from java.lang.Throwable */
15550 {
15553 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15556 continue;
15557 }
15559 /* Partial check for unreachable catch statement: The catch
15560 clause is reachable iff is no earlier catch block A in
15561 the try statement such that the type of the catch
15562 clause's parameter is the same as or a subclass of the
15563 type of A's parameter */
15567 {
15573 {
15575 parse_error_context
15580 break;
15581 }
15582 }
15583 /* Complete the catch clause block */
15586 {
15588 continue;
15589 }
15595 continue;
15597 /* Things to do here: the exception must be thrown */
15599 /* Link this type to the caught type list */
15601 }
15608 POP_EXCEPTIONS ();
15610 /* Verification ends here */
15612 return error_mark_node;
15617 return node;
15618 }
15620 /* 14.17 The synchronized Statement */
15622 static tree
15625 {
15632 {
15634 return expr;
15635 }
15637 /* We might be trying to synchronize on a STRING_CST */
15641 /* The TYPE of expr must be a reference type */
15643 {
15645 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15647 return error_mark_node;
15648 }
15651 {
15655 return node;
15656 }
15658 /* Generate a try-finally for the synchronized statement, except
15659 that the handler that catches all throw exception calls
15660 _Jv_MonitorExit and then rethrow the exception.
15661 The synchronized statement is then implemented as:
15662 TRY
15663 {
15664 _Jv_MonitorEnter (expression)
15665 synchronized_block
15666 _Jv_MonitorExit (expression)
15667 }
15668 CATCH_ALL
15669 {
15670 e = _Jv_exception_info ();
15671 _Jv_MonitorExit (expression)
15672 Throw (e);
15673 } */
15688 block));
15692 }
15694 /* 14.16 The throw Statement */
15696 static tree
15699 {
15704 /* Thrown expression must be assignable to java.lang.Throwable */
15706 {
15711 /* If the thrown expression was a reference, we further the
15712 compile-time check. */
15714 return error_mark_node;
15715 }
15717 /* At least one of the following must be true */
15719 /* The type of the throw expression is a not checked exception,
15720 i.e. is a unchecked expression. */
15724 /* An instance can't throw a checked exception unless that exception
15725 is explicitely declared in the `throws' clause of each
15726 constructor. This doesn't apply to anonymous classes, since they
15727 don't have declared constructors. */
15728 if (!unchecked_ok
15731 {
15732 tree current;
15737 {
15738 parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
15740 return error_mark_node;
15741 }
15742 }
15744 /* Throw is contained in a try statement and at least one catch
15745 clause can receive the thrown expression or the current method is
15746 declared to throw such an exception. Or, the throw statement is
15747 contained in a method or constructor declaration and the type of
15748 the Expression is assignable to at least one type listed in the
15749 throws clause the declaration. */
15753 {
15754 /* If there is a surrounding try block that has no matching
15755 clatch clause, report it first. A surrounding try block exits
15756 only if there is something after the list of checked
15757 exception thrown by the current function (if any). */
15759 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15761 /* If we have no surrounding try statement and the method doesn't have
15762 any throws, report it now. FIXME */
15764 /* We report that the exception can't be throw from a try block
15765 in all circumstances but when the `throw' is inside a static
15766 block. */
15769 {
15774 else
15778 }
15779 /* Otherwise, the current method doesn't have the appropriate
15780 throws declaration */
15781 else
15782 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15784 return error_mark_node;
15785 }
15790 /* If doing xrefs, keep the location where the `throw' was seen. */
15793 return node;
15794 }
15796 /* Check that exception said to be thrown by method DECL can be
15797 effectively caught from where DECL is invoked. */
15799 static void
15802 tree decl;
15803 {
15804 tree throws;
15805 /* For all the unchecked exceptions thrown by DECL */
15809 {
15810 #if 1
15811 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
15813 continue;
15814 #endif
15817 parse_error_context
15820 else
15821 {
15822 parse_error_context
15823 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15828 }
15829 }
15830 }
15832 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15833 try-catch blocks, OR is listed in the `throws' clause of the
15834 current method. */
15836 static int
15838 tree exception;
15839 {
15842 /* First, all the nested try-catch-finally at that stage. The
15843 last element contains `throws' clause exceptions, if any. */
15847 {
15848 tree caught;
15853 }
15855 }
15857 static void
15859 tree mdecl;
15860 {
15865 {
15868 {
15871 }
15873 }
15874 /* List is inverted here, but it doesn't matter */
15876 }
15878 /* This function goes over all of CLASS_TYPE ctors and checks whether
15879 each of them features at least one unchecked exception in its
15880 `throws' clause. If it's the case, it returns `true', `false'
15881 otherwise. */
15883 static bool
15885 tree class_type;
15886 {
15887 tree current;
15891 {
15894 {
15895 tree throws;
15900 }
15901 /* We return false as we found one ctor that is unfit. */
15903 return false;
15904 }
15905 /* All ctors feature at least one unchecked exception in their
15906 `throws' clause. */
15907 return true;
15908 }
15910 /* 15.24 Conditional Operator ?: */
15912 static tree
15915 {
15923 /* Operands of ?: might be StringBuffers crafted as a result of a
15924 string concatenation. Obtain a descent operand here. */
15933 /* The first expression must be a boolean */
15935 {
15941 }
15943 /* Second and third can be numeric, boolean (i.e. primitive),
15944 references or null. Anything else results in an error */
15951 /* Determine the type of the conditional expression. Same types are
15952 easy to deal with */
15956 /* There are different rules for numeric types */
15958 {
15959 /* if byte/short found, the resulting type is short */
15964 /* If t1 is a constant int and t2 is of type byte, short or char
15965 and t1's value fits in t2, then the resulting type is t2 */
15970 /* If t2 is a constant int and t1 is of type byte, short or char
15971 and t2's value fits in t1, then the resulting type is t1 */
15976 /* Otherwise, binary numeric promotion is applied and the
15977 resulting type is the promoted type of operand 1 and 2 */
15978 else
15982 }
15984 /* Cases of a reference and a null type */
15991 /* Last case: different reference types. If a type can be converted
15992 into the other one by assignment conversion, the latter
15993 determines the type of the expression */
16000 /* If we don't have any resulting type, we're in trouble */
16002 {
16010 }
16013 {
16015 return error_mark_node;
16016 }
16021 return node;
16022 }
16024 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16026 static tree
16029 {
16032 return expr;
16036 {
16041 return expr;
16042 }
16045 }
16047 /* Try to constant fold NODE.
16048 If NODE is not a constant expression, return NULL_EXPR.
16049 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16051 static tree
16053 tree node;
16054 tree context;
16055 {
16060 {
16061 case STRING_CST:
16062 case INTEGER_CST:
16063 case REAL_CST:
16064 return node;
16066 case PLUS_EXPR:
16067 case MINUS_EXPR:
16068 case MULT_EXPR:
16069 case TRUNC_MOD_EXPR:
16070 case RDIV_EXPR:
16071 case LSHIFT_EXPR:
16072 case RSHIFT_EXPR:
16073 case URSHIFT_EXPR:
16074 case BIT_AND_EXPR:
16075 case BIT_XOR_EXPR:
16076 case BIT_IOR_EXPR:
16077 case TRUTH_ANDIF_EXPR:
16078 case TRUTH_ORIF_EXPR:
16079 case EQ_EXPR:
16080 case NE_EXPR:
16081 case GT_EXPR:
16082 case GE_EXPR:
16083 case LT_EXPR:
16084 case LE_EXPR:
16089 return NULL_TREE;
16093 return NULL_TREE;
16097 case UNARY_PLUS_EXPR:
16098 case NEGATE_EXPR:
16099 case TRUTH_NOT_EXPR:
16100 case BIT_NOT_EXPR:
16101 case CONVERT_EXPR:
16105 return NULL_TREE;
16108 break;
16110 case COND_EXPR:
16113 return NULL_TREE;
16117 return NULL_TREE;
16121 return NULL_TREE;
16126 case VAR_DECL:
16127 case FIELD_DECL:
16130 return NULL_TREE;
16132 /* Guard against infinite recursion. */
16138 return val;
16140 case EXPR_WITH_FILE_LOCATION:
16141 /* Compare java_complete_tree and resolve_expression_name. */
16144 {
16146 tree decl;
16148 return NULL_TREE;
16150 {
16154 return NULL_TREE;
16156 }
16157 else
16158 {
16159 /* Install the proper context for the field resolution.
16160 The prior context is restored once the name is
16161 properly qualified. */
16163 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
16170 return NULL_TREE;
16171 }
16172 }
16173 else
16174 {
16178 return NULL_TREE;
16180 return val;
16181 }
16183 #ifdef USE_COMPONENT_REF
16184 case IDENTIFIER:
16185 case COMPONENT_REF:
16186 ?;
16187 #endif
16189 default:
16190 return NULL_TREE;
16191 }
16192 }
16194 #ifdef USE_COMPONENT_REF
16195 /* Context is 'T' for TypeName, 'P' for PackageName,
16196 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16198 tree
16200 tree name;
16202 {
16203 }
16205 tree
16207 tree name;
16209 {
16210 }
16211 #endif
16213 /* Mark P, which is really a `struct parser_ctxt **' for GC. */
16215 static void
16218 {
16223 return;
16225 #ifndef JC1_LITE
16245 }
16247 void
16248 init_src_parse ()
16249 {
16250 /* Register roots with the garbage collector. */
16252 }
16254 \f
16256 /* This section deals with the functions that are called when tables
16257 recording class initialization information are traversed. */
16259 /* Attach to PTR (a block) the declaration found in ENTRY. */
16261 static bool
16264 PTR ptr;
16265 {
16271 return true;
16272 }
16274 /* This function is called for each statement calling a static
16275 function. ENTRY is a TREE_LIST whose PURPOSE is the called
16276 function and VALUE is a compound whose second operand can be
16277 patched with static class initialization flag assignments. */
16279 static bool
16282 PTR info ATTRIBUTE_UNUSED;
16283 {
16289 /* For each class definitely initialized in CALLED_METHOD, fill
16290 ASSIGNMENT_COMPOUND with assignment to the class initialization flag. */
16297 return true;
16298 }
16300 /* This function is called for each classes that is known definitely
16301 assigned when a given static method was called. This function
16302 augments a compound expression (INFO) storing all assignment to
16303 initialized static class flags if a flag already existed, otherwise
16304 a new one is created. */
16306 static bool
16309 PTR info;
16310 {
16318 /* If we haven't found a flag and we're dealing with self registered
16319 with current_function_decl, then don't do anything. Self is
16320 always added as definitely initialized but this information is
16321 valid only if used outside the current function. */
16323 {
16328 else
16329 return true;
16330 }
16332 /* If we don't have a variable, create one and install it. */
16334 {
16335 tree block;
16343 /* The trick is to find the right context for it. */
16348 }
16349 else
16352 /* Now simply augment the compound that holds all the assignments
16353 pertaining to this method invocation. */
16359 return true;
16360 }