| blob | d35a47dbc8ea94d45da238037384a4713c81f867 |
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;
299 /* JDK 1.1 work. FIXME */
342 PTR));
344 PTR));
347 /* Number of error found so far. */
349 /* Number of warning found so far. */
351 /* Tell when not to fold, when doing xrefs */
353 /* Cyclic inheritance report, as it can be set by layout_class */
356 /* The current parser context */
359 /* List of things that were analyzed for which code will be generated */
362 /* binop_lookup maps token to tree_code. It is used where binary
363 operations are involved and required by the parser. RDIV_EXPR
364 covers both integral/floating point division. The code is changed
365 once the type of both operator is worked out. */
368 {
374 };
375 #define BINOP_LOOKUP(VALUE) \
378 /* This is the end index for binary operators that can also be used
379 in compound assignements. */
380 #define BINOP_COMPOUND_CANDIDATES 11
382 /* The "$L" identifier we use to create labels. */
385 /* The "StringBuffer" identifier used for the String `+' operator. */
388 /* The "append" identifier used for String `+' operator. */
391 /* The "toString" identifier used for String `+' operator. */
394 /* The "java.lang" import qualified name. */
397 /* The generated `inst$' identifier used for generated enclosing
398 instance/field access functions. */
401 /* The "java.lang.Cloneable" qualified name. */
404 /* The "java.io.Serializable" qualified name. */
407 /* Context and flag for static blocks */
410 /* The generated `write_parm_value$' identifier. */
413 /* The list of all packages we've seen so far */
416 /* Hold THIS for the scope of the current public method decl. */
419 /* Hold a list of catch clauses list. The first element of this list is
420 the list of the catch clauses of the currently analysed try block. */
425 /* All classes seen from source code */
426 #define gclass_list src_parse_roots[0]
428 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
429 line and point it out. */
430 /* Should point out the one that don't fit. ASCII/unicode, going
431 backward. FIXME */
433 #define check_modifiers(__message, __value, __mask) do { \
435 { \
441 } \
444 %}
447 tree node;
454 }
456 %{
458 %}
460 %pure_parser
462 /* Things defined here have to match the order of what's in the
463 binop_lookup table. */
465 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
466 %token LS_TK SRS_TK ZRS_TK
467 %token AND_TK XOR_TK OR_TK
468 %token BOOL_AND_TK BOOL_OR_TK
469 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
471 /* This maps to the same binop_lookup entry than the token above */
473 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
474 %token REM_ASSIGN_TK
475 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
476 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
479 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
481 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
482 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
483 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
484 %token PAD_TK ABSTRACT_TK MODIFIER_TK
485 %token STRICT_TK
487 /* Keep those two in order, too */
488 %token DECR_TK INCR_TK
490 /* From now one, things can be in any order */
492 %token DEFAULT_TK IF_TK THROW_TK
493 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
494 %token THROWS_TK BREAK_TK IMPORT_TK
495 %token ELSE_TK INSTANCEOF_TK RETURN_TK
496 %token VOID_TK CATCH_TK INTERFACE_TK
497 %token CASE_TK EXTENDS_TK FINALLY_TK
498 %token SUPER_TK WHILE_TK CLASS_TK
499 %token SWITCH_TK CONST_TK TRY_TK
500 %token FOR_TK NEW_TK CONTINUE_TK
501 %token GOTO_TK PACKAGE_TK THIS_TK
503 %token BYTE_TK SHORT_TK INT_TK LONG_TK
504 %token CHAR_TK INTEGRAL_TK
506 %token FLOAT_TK DOUBLE_TK FP_TK
508 %token ID_TK
510 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
512 %token ASSIGN_ANY_TK ASSIGN_TK
513 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
515 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
516 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
523 field_declaration method_declaration extends_interfaces
524 interfaces interface_type_list
525 class_member_declaration
526 import_declarations package_declaration
527 type_declarations interface_body
528 interface_member_declaration constant_declaration
529 interface_member_declarations interface_type
530 abstract_method_declaration interface_type_list
532 static_initializer constructor_declaration block
535 constructor_declarator explicit_constructor_invocation
539 variable_declarators variable_initializer
540 variable_initializers constructor_body
541 array_initializer
545 labeled_statement if_then_statement label_decl
546 if_then_else_statement while_statement for_statement
547 statement_nsi labeled_statement_nsi do_statement
548 if_then_else_statement_nsi while_statement_nsi
549 for_statement_nsi statement_expression_list for_init
550 for_update statement_expression expression_statement
551 primary_no_new_array expression primary
552 array_creation_expression array_type
553 class_instance_creation_expression field_access
554 method_invocation array_access something_dot_new
555 argument_list postfix_expression while_expression
556 post_increment_expression post_decrement_expression
557 unary_expression_not_plus_minus unary_expression
558 pre_increment_expression pre_decrement_expression
559 unary_expression_not_plus_minus cast_expression
560 multiplicative_expression additive_expression
561 shift_expression relational_expression
562 equality_expression and_expression
563 exclusive_or_expression inclusive_or_expression
564 conditional_and_expression conditional_or_expression
565 conditional_expression assignment_expression
566 left_hand_side assignment for_header for_begin
567 constant_expression do_statement_begin empty_statement
568 switch_statement synchronized_statement throw_statement
569 try_statement switch_expression switch_block
570 catches catch_clause catch_clause_parameter finally
571 anonymous_class_creation
591 STRING_LIT_TK NULL_TK VOID_TK
596 method_declarator method_header
599 BOOLEAN_TK INTEGRAL_TK FP_TK
601 /* Added or modified JDK 1.1 rule types */
604 %%
605 /* 19.2 Production from 2.3: The Syntactic Grammar */
606 goal:
607 {
608 /* Register static variables with the garbage
609 collector. */
625 mark_parser_ctxt);
628 mark_parser_ctxt);
629 }
630 compilation_unit
631 {}
632 ;
634 /* 19.3 Productions from 3: Lexical structure */
635 literal:
636 INT_LIT_TK
637 | FP_LIT_TK
638 | BOOL_LIT_TK
639 | CHAR_LIT_TK
640 | STRING_LIT_TK
641 | NULL_TK
642 ;
644 /* 19.4 Productions from 4: Types, Values and Variables */
645 type:
646 primitive_type
647 | reference_type
648 ;
650 primitive_type:
651 INTEGRAL_TK
652 | FP_TK
653 | BOOLEAN_TK
654 ;
656 reference_type:
657 class_or_interface_type
658 | array_type
659 ;
661 class_or_interface_type:
662 name
663 ;
665 class_type:
666 class_or_interface_type /* Default rule */
667 ;
669 interface_type:
670 class_or_interface_type
671 ;
673 array_type:
674 primitive_type dims
675 {
681 }
682 | name dims
683 {
689 }
690 ;
692 /* 19.5 Productions from 6: Names */
693 name:
694 simple_name /* Default rule */
695 | qualified_name /* Default rule */
696 ;
698 simple_name:
699 identifier /* Default rule */
700 ;
702 qualified_name:
703 name DOT_TK identifier
705 ;
707 identifier:
708 ID_TK
709 ;
711 /* 19.6: Production from 7: Packages */
712 compilation_unit:
714 | package_declaration
715 | import_declarations
716 | type_declarations
717 | package_declaration import_declarations
718 | package_declaration type_declarations
719 | import_declarations type_declarations
720 | package_declaration import_declarations type_declarations
721 ;
723 import_declarations:
724 import_declaration
725 {
727 }
728 | import_declarations import_declaration
729 {
731 }
732 ;
734 type_declarations:
735 type_declaration
736 | type_declarations type_declaration
737 ;
739 package_declaration:
740 PACKAGE_TK name SC_TK
741 {
744 }
745 | PACKAGE_TK error
747 | PACKAGE_TK name error
749 ;
751 import_declaration:
752 single_type_import_declaration
753 | type_import_on_demand_declaration
754 ;
756 single_type_import_declaration:
757 IMPORT_TK name SC_TK
758 {
763 {
765 break;
766 last--;
767 }
770 {
773 parse_error_context
777 else
779 }
780 else
782 }
783 | IMPORT_TK error
785 | IMPORT_TK name error
787 ;
789 type_import_on_demand_declaration:
790 IMPORT_TK name DOT_TK MULT_TK SC_TK
791 {
793 tree it;
794 /* Search for duplicates. */
797 break;
798 /* Don't import the same thing more than once, just ignore
799 duplicates (7.5.2) */
801 {
806 }
807 }
808 | IMPORT_TK name DOT_TK error
810 | IMPORT_TK name DOT_TK MULT_TK error
812 ;
814 type_declaration:
815 class_declaration
817 | interface_declaration
819 | empty_statement
820 | error
821 {
822 YYERROR_NOW;
824 }
825 ;
827 /* 19.7 Shortened from the original:
828 modifiers: modifier | modifiers modifier
829 modifier: any of public... */
830 modifiers:
831 MODIFIER_TK
832 {
834 }
835 | modifiers MODIFIER_TK
836 {
839 parse_error_context
842 else
843 {
845 }
846 }
847 ;
849 /* 19.8.1 Production from $8.1: Class Declaration */
850 class_declaration:
851 modifiers CLASS_TK identifier super interfaces
853 class_body
854 | CLASS_TK identifier super interfaces
856 class_body
857 | modifiers CLASS_TK error
859 | CLASS_TK error
861 | CLASS_TK identifier error
862 {
865 }
866 | modifiers CLASS_TK identifier error
868 ;
870 super:
872 | EXTENDS_TK class_type
874 | EXTENDS_TK class_type error
876 | EXTENDS_TK error
878 ;
880 interfaces:
882 | IMPLEMENTS_TK interface_type_list
884 | IMPLEMENTS_TK error
885 {
888 }
889 ;
891 interface_type_list:
892 interface_type
893 {
896 }
897 | interface_type_list C_TK interface_type
898 {
901 }
902 | interface_type_list C_TK error
904 ;
906 class_body:
907 OCB_TK CCB_TK
908 {
909 /* Store the location of the `}' when doing xrefs */
914 }
915 | OCB_TK class_body_declarations CCB_TK
916 {
917 /* Store the location of the `}' when doing xrefs */
922 }
923 ;
925 class_body_declarations:
926 class_body_declaration
927 | class_body_declarations class_body_declaration
928 ;
930 class_body_declaration:
931 class_member_declaration
932 | static_initializer
933 | constructor_declaration
934 | block /* Added, JDK1.1, instance initializer */
935 {
937 {
940 }
941 }
942 ;
944 class_member_declaration:
945 field_declaration
946 | method_declaration
947 | class_declaration /* Added, JDK1.1 inner classes */
949 | interface_declaration /* Added, JDK1.1 inner interfaces */
951 | empty_statement
952 ;
954 /* 19.8.2 Productions from 8.3: Field Declarations */
955 field_declaration:
956 type variable_declarators SC_TK
958 | modifiers type variable_declarators SC_TK
959 {
960 check_modifiers
965 }
966 ;
968 variable_declarators:
969 /* Should we use build_decl_list () instead ? FIXME */
970 variable_declarator /* Default rule */
971 | variable_declarators C_TK variable_declarator
973 | variable_declarators C_TK error
975 ;
977 variable_declarator:
978 variable_declarator_id
980 | variable_declarator_id ASSIGN_TK variable_initializer
981 {
984 $$ = build_tree_list
986 }
987 | variable_declarator_id ASSIGN_TK error
988 {
991 RECOVER;
992 }
993 | variable_declarator_id ASSIGN_TK variable_initializer error
994 {
997 RECOVER;
998 }
999 ;
1001 variable_declarator_id:
1002 identifier
1003 | variable_declarator_id OSB_TK CSB_TK
1005 | identifier error
1007 | variable_declarator_id OSB_TK error
1008 {
1013 else
1016 }
1017 | variable_declarator_id CSB_TK error
1019 ;
1021 variable_initializer:
1022 expression
1023 | array_initializer
1024 ;
1026 /* 19.8.3 Productions from 8.4: Method Declarations */
1027 method_declaration:
1028 method_header
1029 {
1031 if (current_function_decl
1034 else
1036 }
1037 method_body
1039 | method_header error
1041 ;
1043 method_header:
1044 type method_declarator throws
1046 | VOID_TK method_declarator throws
1048 | modifiers type method_declarator throws
1050 | modifiers VOID_TK method_declarator throws
1052 | type error
1053 {
1055 RECOVER;
1056 }
1057 | modifiers type error
1059 | VOID_TK error
1061 | modifiers VOID_TK error
1063 | modifiers error
1064 {
1066 RECOVER;
1067 }
1068 ;
1070 method_declarator:
1071 identifier OP_TK CP_TK
1072 {
1075 }
1076 | identifier OP_TK formal_parameter_list CP_TK
1078 | method_declarator OSB_TK CSB_TK
1079 {
1083 parse_warning_context
1086 }
1087 | identifier OP_TK error
1089 | method_declarator OSB_TK error
1091 ;
1093 formal_parameter_list:
1094 formal_parameter
1095 {
1097 }
1098 | formal_parameter_list C_TK formal_parameter
1099 {
1102 }
1103 | formal_parameter_list C_TK error
1105 ;
1107 formal_parameter:
1108 type variable_declarator_id
1109 {
1111 }
1112 | final type variable_declarator_id /* Added, JDK1.1 final parms */
1113 {
1116 }
1117 | type error
1118 {
1121 }
1122 | final type error
1123 {
1126 }
1127 ;
1129 final:
1130 modifiers
1131 {
1136 }
1137 ;
1139 throws:
1141 | THROWS_TK class_type_list
1143 | THROWS_TK error
1145 ;
1147 class_type_list:
1148 class_type
1150 | class_type_list C_TK class_type
1152 | class_type_list C_TK error
1154 ;
1156 method_body:
1157 block
1159 ;
1161 /* 19.8.4 Productions from 8.5: Static Initializers */
1162 static_initializer:
1163 static block
1164 {
1168 }
1169 ;
1172 modifiers
1173 {
1175 /* Can't have a static initializer in an innerclass */
1178 parse_error_context
1180 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1183 }
1184 ;
1186 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1187 constructor_declaration:
1188 constructor_header
1189 {
1192 }
1193 constructor_body
1195 ;
1197 constructor_header:
1198 constructor_declarator throws
1200 | modifiers constructor_declarator throws
1202 ;
1204 constructor_declarator:
1205 simple_name OP_TK CP_TK
1206 {
1209 }
1210 | simple_name OP_TK formal_parameter_list CP_TK
1212 ;
1214 constructor_body:
1215 /* Unlike regular method, we always need a complete (empty)
1216 body so we can safely perform all the required code
1217 addition (super invocation and field initialization) */
1218 block_begin constructor_block_end
1219 {
1222 }
1223 | block_begin explicit_constructor_invocation constructor_block_end
1225 | block_begin block_statements constructor_block_end
1227 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1229 ;
1231 constructor_block_end:
1232 block_end
1233 ;
1235 /* Error recovery for that rule moved down expression_statement: rule. */
1236 explicit_constructor_invocation:
1237 this_or_super OP_TK CP_TK SC_TK
1238 {
1242 }
1243 | this_or_super OP_TK argument_list CP_TK SC_TK
1244 {
1248 }
1249 /* Added, JDK1.1 inner classes. Modified because the rule
1250 'primary' couldn't work. */
1251 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1253 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1255 ;
1258 THIS_TK
1259 {
1263 }
1264 | SUPER_TK
1265 {
1269 }
1270 ;
1272 /* 19.9 Productions from 9: Interfaces */
1273 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1274 interface_declaration:
1275 INTERFACE_TK identifier
1277 interface_body
1278 | modifiers INTERFACE_TK identifier
1280 interface_body
1281 | INTERFACE_TK identifier extends_interfaces
1283 interface_body
1284 | modifiers INTERFACE_TK identifier extends_interfaces
1286 interface_body
1287 | INTERFACE_TK identifier error
1289 | modifiers INTERFACE_TK identifier error
1291 ;
1293 extends_interfaces:
1294 EXTENDS_TK interface_type
1295 {
1298 }
1299 | extends_interfaces C_TK interface_type
1300 {
1303 }
1304 | EXTENDS_TK error
1306 | extends_interfaces C_TK error
1308 ;
1310 interface_body:
1311 OCB_TK CCB_TK
1313 | OCB_TK interface_member_declarations CCB_TK
1315 ;
1317 interface_member_declarations:
1318 interface_member_declaration
1319 | interface_member_declarations interface_member_declaration
1320 ;
1322 interface_member_declaration:
1323 constant_declaration
1324 | abstract_method_declaration
1325 | class_declaration /* Added, JDK1.1 inner classes */
1327 | interface_declaration /* Added, JDK1.1 inner interfaces */
1329 ;
1331 constant_declaration:
1332 field_declaration
1333 ;
1335 abstract_method_declaration:
1336 method_header SC_TK
1337 {
1340 }
1341 | method_header error
1343 ;
1345 /* 19.10 Productions from 10: Arrays */
1346 array_initializer:
1347 OCB_TK CCB_TK
1349 | OCB_TK variable_initializers CCB_TK
1351 | OCB_TK variable_initializers C_TK CCB_TK
1353 ;
1355 variable_initializers:
1356 variable_initializer
1357 {
1360 }
1361 | variable_initializers C_TK variable_initializer
1362 {
1364 }
1365 | variable_initializers C_TK error
1367 ;
1369 /* 19.11 Production from 14: Blocks and Statements */
1370 block:
1371 OCB_TK CCB_TK
1372 {
1373 /* Store the location of the `}' when doing xrefs */
1378 }
1379 | block_begin block_statements block_end
1381 ;
1383 block_begin:
1384 OCB_TK
1386 ;
1388 block_end:
1389 CCB_TK
1390 {
1391 maybe_absorb_scoping_blocks ();
1392 /* Store the location of the `}' when doing xrefs */
1399 }
1400 ;
1402 block_statements:
1403 block_statement
1404 | block_statements block_statement
1405 ;
1407 block_statement:
1408 local_variable_declaration_statement
1409 | statement
1411 | class_declaration /* Added, JDK1.1 local classes */
1412 {
1415 }
1416 ;
1418 local_variable_declaration_statement:
1419 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1420 ;
1422 local_variable_declaration:
1423 type variable_declarators
1425 | final type variable_declarators /* Added, JDK1.1 final locals */
1427 ;
1429 statement:
1430 statement_without_trailing_substatement
1431 | labeled_statement
1432 | if_then_statement
1433 | if_then_else_statement
1434 | while_statement
1435 | for_statement
1437 ;
1439 statement_nsi:
1440 statement_without_trailing_substatement
1441 | labeled_statement_nsi
1442 | if_then_else_statement_nsi
1443 | while_statement_nsi
1444 | for_statement_nsi
1446 ;
1448 statement_without_trailing_substatement:
1449 block
1450 | empty_statement
1451 | expression_statement
1452 | switch_statement
1453 | do_statement
1454 | break_statement
1455 | continue_statement
1456 | return_statement
1457 | synchronized_statement
1458 | throw_statement
1459 | try_statement
1460 ;
1462 empty_statement:
1463 SC_TK
1464 {
1465 if (flag_extraneous_semicolon
1466 && ! current_static_block
1467 && (! current_function_decl ||
1468 /* Verify we're not in a inner class declaration */
1472 {
1474 parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1475 }
1477 }
1478 ;
1480 label_decl:
1481 identifier REL_CL_TK
1482 {
1488 }
1489 ;
1491 labeled_statement:
1492 label_decl statement
1494 | identifier error
1496 ;
1498 labeled_statement_nsi:
1499 label_decl statement_nsi
1501 ;
1503 /* We concentrate here a bunch of error handling rules that we couldn't write
1504 earlier, because expression_statement catches a missing ';'. */
1505 expression_statement:
1506 statement_expression SC_TK
1507 {
1508 /* We have a statement. Generate a WFL around it so
1509 we can debug it */
1511 /* We know we have a statement, so set the debug
1512 info to be eventually generate here. */
1514 }
1515 | error SC_TK
1516 {
1519 }
1520 | error OCB_TK
1521 {
1524 }
1525 | error CCB_TK
1526 {
1529 }
1530 | this_or_super OP_TK error
1532 | this_or_super OP_TK CP_TK error
1533 {
1534 parse_ctor_invocation_error ();
1535 RECOVER;
1536 }
1537 | this_or_super OP_TK argument_list error
1539 | this_or_super OP_TK argument_list CP_TK error
1540 {
1541 parse_ctor_invocation_error ();
1542 RECOVER;
1543 }
1544 | name DOT_TK SUPER_TK error
1546 | name DOT_TK SUPER_TK OP_TK error
1548 | name DOT_TK SUPER_TK OP_TK argument_list error
1550 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1552 | name DOT_TK SUPER_TK OP_TK CP_TK error
1554 ;
1556 statement_expression:
1557 assignment
1558 | pre_increment_expression
1559 | pre_decrement_expression
1560 | post_increment_expression
1561 | post_decrement_expression
1562 | method_invocation
1563 | class_instance_creation_expression
1564 ;
1566 if_then_statement:
1567 IF_TK OP_TK expression CP_TK statement
1568 {
1571 }
1572 | IF_TK error
1574 | IF_TK OP_TK error
1576 | IF_TK OP_TK expression error
1578 ;
1580 if_then_else_statement:
1581 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1583 ;
1585 if_then_else_statement_nsi:
1586 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1588 ;
1590 switch_statement:
1591 switch_expression
1592 {
1593 enter_block ();
1594 }
1595 switch_block
1596 {
1597 /* Make into "proper list" of COMPOUND_EXPRs.
1598 I.e. make the last statment also have its own
1599 COMPOUND_EXPR. */
1600 maybe_absorb_scoping_blocks ();
1603 }
1604 ;
1606 switch_expression:
1607 SWITCH_TK OP_TK expression CP_TK
1608 {
1611 }
1612 | SWITCH_TK error
1614 | SWITCH_TK OP_TK error
1616 | SWITCH_TK OP_TK expression CP_TK error
1618 ;
1620 /* Default assignment is there to avoid type node on switch_block
1621 node. */
1623 switch_block:
1624 OCB_TK CCB_TK
1626 | OCB_TK switch_labels CCB_TK
1628 | OCB_TK switch_block_statement_groups CCB_TK
1630 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1632 ;
1634 switch_block_statement_groups:
1635 switch_block_statement_group
1636 | switch_block_statement_groups switch_block_statement_group
1637 ;
1639 switch_block_statement_group:
1640 switch_labels block_statements
1641 ;
1643 switch_labels:
1644 switch_label
1645 | switch_labels switch_label
1646 ;
1648 switch_label:
1649 CASE_TK constant_expression REL_CL_TK
1650 {
1654 }
1655 | DEFAULT_TK REL_CL_TK
1656 {
1660 }
1661 | CASE_TK error
1663 | CASE_TK constant_expression error
1665 | DEFAULT_TK error
1667 ;
1669 while_expression:
1670 WHILE_TK OP_TK expression CP_TK
1671 {
1674 }
1675 ;
1677 while_statement:
1678 while_expression statement
1680 | WHILE_TK error
1682 | WHILE_TK OP_TK error
1684 | WHILE_TK OP_TK expression error
1686 ;
1688 while_statement_nsi:
1689 while_expression statement_nsi
1691 ;
1693 do_statement_begin:
1694 DO_TK
1695 {
1698 }
1699 /* Need error handing here. FIXME */
1700 ;
1702 do_statement:
1703 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1705 ;
1707 for_statement:
1708 for_begin SC_TK expression SC_TK for_update CP_TK statement
1709 {
1713 }
1714 | for_begin SC_TK SC_TK for_update CP_TK statement
1715 {
1717 /* We have not condition, so we get rid of the EXIT_EXPR */
1719 empty_stmt_node;
1720 }
1721 | for_begin SC_TK error
1723 | for_begin SC_TK expression SC_TK error
1725 | for_begin SC_TK SC_TK error
1727 ;
1729 for_statement_nsi:
1730 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1732 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1733 {
1735 /* We have not condition, so we get rid of the EXIT_EXPR */
1737 empty_stmt_node;
1738 }
1739 ;
1741 for_header:
1742 FOR_TK OP_TK
1743 {
1744 /* This scope defined for local variable that may be
1745 defined within the scope of the for loop */
1746 enter_block ();
1747 }
1748 | FOR_TK error
1750 | FOR_TK OP_TK error
1752 ;
1754 for_begin:
1755 for_header for_init
1756 {
1757 /* We now declare the loop body. The loop is
1758 declared as a for loop. */
1762 /* The loop is added to the current block the for
1763 statement is defined within */
1765 }
1766 ;
1769 | statement_expression_list
1770 {
1771 /* Init statement recorded within the previously
1772 defined block scope */
1774 }
1775 | local_variable_declaration
1776 {
1777 /* Local variable are recorded within the previously
1778 defined block scope */
1780 }
1781 | statement_expression_list error
1783 ;
1787 | statement_expression_list
1789 ;
1791 statement_expression_list:
1792 statement_expression
1794 | statement_expression_list C_TK statement_expression
1796 | statement_expression_list C_TK error
1798 ;
1800 break_statement:
1801 BREAK_TK SC_TK
1803 | BREAK_TK identifier SC_TK
1805 | BREAK_TK error
1807 | BREAK_TK identifier error
1809 ;
1811 continue_statement:
1812 CONTINUE_TK SC_TK
1814 | CONTINUE_TK identifier SC_TK
1816 | CONTINUE_TK error
1818 | CONTINUE_TK identifier error
1820 ;
1822 return_statement:
1823 RETURN_TK SC_TK
1825 | RETURN_TK expression SC_TK
1827 | RETURN_TK error
1829 | RETURN_TK expression error
1831 ;
1833 throw_statement:
1834 THROW_TK expression SC_TK
1835 {
1838 }
1839 | THROW_TK error
1841 | THROW_TK expression error
1843 ;
1845 synchronized_statement:
1846 synchronized OP_TK expression CP_TK block
1847 {
1851 }
1852 | synchronized OP_TK expression CP_TK error
1854 | synchronized error
1856 | synchronized OP_TK error CP_TK
1858 | synchronized OP_TK error
1860 ;
1862 synchronized:
1863 modifiers
1864 {
1865 check_modifiers (
1871 }
1872 ;
1874 try_statement:
1875 TRY_TK block catches
1877 | TRY_TK block finally
1879 | TRY_TK block catches finally
1883 }
1884 | TRY_TK error
1886 ;
1888 catches:
1889 catch_clause
1890 | catches catch_clause
1891 {
1894 }
1895 ;
1897 catch_clause:
1898 catch_clause_parameter block
1899 {
1901 exit_block ();
1903 }
1905 catch_clause_parameter:
1906 CATCH_TK OP_TK formal_parameter CP_TK
1907 {
1908 /* We add a block to define a scope for
1909 formal_parameter (CCBP). The formal parameter is
1910 declared initialized by the appropriate function
1911 call */
1913 tree init = build_assignment
1918 init));
1921 }
1922 | CATCH_TK error
1924 | CATCH_TK OP_TK error
1925 {
1928 }
1931 ;
1933 finally:
1934 FINALLY_TK block
1936 | FINALLY_TK error
1938 ;
1940 /* 19.12 Production from 15: Expressions */
1941 primary:
1942 primary_no_new_array
1943 | array_creation_expression
1944 ;
1946 primary_no_new_array:
1947 literal
1948 | THIS_TK
1950 | OP_TK expression CP_TK
1952 | class_instance_creation_expression
1953 | field_access
1954 | method_invocation
1955 | array_access
1956 | type_literals
1957 /* Added, JDK1.1 inner classes. Documentation is wrong
1958 refering to a 'ClassName' (class_name) rule that doesn't
1959 exist. Used name: instead. */
1960 | name DOT_TK THIS_TK
1961 {
1964 }
1965 | OP_TK expression error
1967 | name DOT_TK error
1969 | primitive_type DOT_TK error
1971 | VOID_TK DOT_TK error
1973 ;
1975 type_literals:
1976 name DOT_TK CLASS_TK
1978 | array_type DOT_TK CLASS_TK
1980 | primitive_type DOT_TK CLASS_TK
1982 | VOID_TK DOT_TK CLASS_TK
1983 {
1985 void_type_node);
1986 }
1987 ;
1989 class_instance_creation_expression:
1990 NEW_TK class_type OP_TK argument_list CP_TK
1992 | NEW_TK class_type OP_TK CP_TK
1994 | anonymous_class_creation
1995 /* Added, JDK1.1 inner classes, modified to use name or
1996 primary instead of primary solely which couldn't work in
1997 all situations. */
1998 | something_dot_new identifier OP_TK CP_TK
1999 {
2003 }
2004 | something_dot_new identifier OP_TK CP_TK class_body
2005 | something_dot_new identifier OP_TK argument_list CP_TK
2006 {
2010 }
2011 | something_dot_new identifier OP_TK argument_list CP_TK class_body
2012 | NEW_TK error SC_TK
2014 | NEW_TK class_type error
2016 | NEW_TK class_type OP_TK error
2018 | NEW_TK class_type OP_TK argument_list error
2020 | something_dot_new error
2022 | something_dot_new identifier error
2024 ;
2026 /* Created after JDK1.1 rules originally added to
2027 class_instance_creation_expression, but modified to use
2028 'class_type' instead of 'TypeName' (type_name) which is mentionned
2029 in the documentation but doesn't exist. */
2031 anonymous_class_creation:
2032 NEW_TK class_type OP_TK argument_list CP_TK
2034 class_body
2035 {
2041 /* Now we can craft the new expression */
2044 /* Note that we can't possibly be here if
2045 `class_type' is an interface (in which case the
2046 anonymous class extends Object and implements
2047 `class_type', hence its constructor can't have
2048 arguments.) */
2050 /* Otherwise, the innerclass must feature a
2051 constructor matching `argument_list'. Anonymous
2052 classes are a bit special: it's impossible to
2053 define constructor for them, hence constructors
2054 must be generated following the hints provided by
2055 the `new' expression. Whether a super constructor
2056 of that nature exists or not is to be verified
2057 later on in verify_constructor_super.
2059 It's during the expansion of a `new' statement
2060 refering to an anonymous class that a ctor will
2061 be generated for the anonymous class, with the
2062 right arguments. */
2064 }
2065 | NEW_TK class_type OP_TK CP_TK
2067 class_body
2068 {
2074 /* Now we can craft the new expression. The
2075 statement doesn't need to be remember so that a
2076 constructor can be generated, since its signature
2077 is already known. */
2079 }
2080 ;
2083 name DOT_TK NEW_TK
2085 | primary DOT_TK NEW_TK
2087 ;
2089 argument_list:
2090 expression
2091 {
2094 }
2095 | argument_list C_TK expression
2096 {
2099 }
2100 | argument_list C_TK error
2102 ;
2104 array_creation_expression:
2105 NEW_TK primitive_type dim_exprs
2107 | NEW_TK class_or_interface_type dim_exprs
2109 | NEW_TK primitive_type dim_exprs dims
2111 | NEW_TK class_or_interface_type dim_exprs dims
2113 /* Added, JDK1.1 anonymous array. Initial documentation rule
2114 modified */
2115 | NEW_TK class_or_interface_type dims array_initializer
2116 {
2124 }
2125 | NEW_TK primitive_type dims array_initializer
2126 {
2133 }
2134 | NEW_TK error CSB_TK
2136 | NEW_TK error OSB_TK
2138 ;
2140 dim_exprs:
2141 dim_expr
2143 | dim_exprs dim_expr
2145 ;
2147 dim_expr:
2148 OSB_TK expression CSB_TK
2149 {
2151 {
2154 }
2157 }
2158 | OSB_TK expression error
2160 | OSB_TK error
2161 {
2164 RECOVER;
2165 }
2166 ;
2168 dims:
2169 OSB_TK CSB_TK
2170 {
2172 /* If not initialized, allocate memory for the osb
2173 numbers stack */
2175 {
2178 }
2179 /* If capacity overflown, reallocate a bigger chunk */
2184 {
2188 allocate);
2189 else
2191 }
2194 }
2195 | dims OSB_TK CSB_TK
2197 | dims OSB_TK error
2199 ;
2201 field_access:
2202 primary DOT_TK identifier
2204 /* FIXME - REWRITE TO:
2205 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2206 | SUPER_TK DOT_TK identifier
2207 {
2211 }
2212 | SUPER_TK error
2214 ;
2216 method_invocation:
2217 name OP_TK CP_TK
2219 | name OP_TK argument_list CP_TK
2221 | primary DOT_TK identifier OP_TK CP_TK
2222 {
2224 $$ = build_this_super_qualified_invocation
2226 else
2227 {
2230 }
2231 }
2232 | primary DOT_TK identifier OP_TK argument_list CP_TK
2233 {
2235 $$ = build_this_super_qualified_invocation
2237 else
2238 {
2241 }
2242 }
2243 | SUPER_TK DOT_TK identifier OP_TK CP_TK
2244 {
2245 $$ = build_this_super_qualified_invocation
2247 }
2248 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2249 {
2250 $$ = build_this_super_qualified_invocation
2252 }
2253 /* Screws up thing. I let it here until I'm convinced it can
2254 be removed. FIXME
2255 | primary DOT_TK error
2256 {yyerror ("'(' expected"); DRECOVER(bad);} */
2257 | SUPER_TK DOT_TK error CP_TK
2259 | SUPER_TK DOT_TK error DOT_TK
2261 ;
2263 array_access:
2264 name OSB_TK expression CSB_TK
2266 | primary_no_new_array OSB_TK expression CSB_TK
2268 | name OSB_TK error
2269 {
2272 }
2273 | name OSB_TK expression error
2274 {
2277 }
2278 | primary_no_new_array OSB_TK error
2279 {
2282 }
2283 | primary_no_new_array OSB_TK expression error
2284 {
2287 }
2288 ;
2290 postfix_expression:
2291 primary
2292 | name
2293 | post_increment_expression
2294 | post_decrement_expression
2295 ;
2297 post_increment_expression:
2298 postfix_expression INCR_TK
2300 ;
2302 post_decrement_expression:
2303 postfix_expression DECR_TK
2305 ;
2307 unary_expression:
2308 pre_increment_expression
2309 | pre_decrement_expression
2310 | PLUS_TK unary_expression
2312 | MINUS_TK unary_expression
2314 | unary_expression_not_plus_minus
2315 | PLUS_TK error
2317 | MINUS_TK error
2319 ;
2321 pre_increment_expression:
2322 INCR_TK unary_expression
2324 | INCR_TK error
2326 ;
2328 pre_decrement_expression:
2329 DECR_TK unary_expression
2331 | DECR_TK error
2333 ;
2335 unary_expression_not_plus_minus:
2336 postfix_expression
2337 | NOT_TK unary_expression
2339 | NEG_TK unary_expression
2341 | cast_expression
2342 | NOT_TK error
2344 | NEG_TK error
2346 ;
2349 OP_TK primitive_type dims CP_TK unary_expression
2350 {
2356 }
2357 | OP_TK primitive_type CP_TK unary_expression
2359 | OP_TK expression CP_TK unary_expression_not_plus_minus
2361 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2362 {
2373 }
2374 | OP_TK primitive_type OSB_TK error
2376 | OP_TK error
2377 {
2379 RECOVER;
2380 }
2381 | OP_TK primitive_type dims CP_TK error
2383 | OP_TK primitive_type CP_TK error
2385 | OP_TK name dims CP_TK error
2387 ;
2389 multiplicative_expression:
2390 unary_expression
2391 | multiplicative_expression MULT_TK unary_expression
2392 {
2395 }
2396 | multiplicative_expression DIV_TK unary_expression
2397 {
2400 }
2401 | multiplicative_expression REM_TK unary_expression
2402 {
2405 }
2406 | multiplicative_expression MULT_TK error
2408 | multiplicative_expression DIV_TK error
2410 | multiplicative_expression REM_TK error
2412 ;
2414 additive_expression:
2415 multiplicative_expression
2416 | additive_expression PLUS_TK multiplicative_expression
2417 {
2420 }
2421 | additive_expression MINUS_TK multiplicative_expression
2422 {
2425 }
2426 | additive_expression PLUS_TK error
2428 | additive_expression MINUS_TK error
2430 ;
2432 shift_expression:
2433 additive_expression
2434 | shift_expression LS_TK additive_expression
2435 {
2438 }
2439 | shift_expression SRS_TK additive_expression
2440 {
2443 }
2444 | shift_expression ZRS_TK additive_expression
2445 {
2448 }
2449 | shift_expression LS_TK error
2451 | shift_expression SRS_TK error
2453 | shift_expression ZRS_TK error
2455 ;
2457 relational_expression:
2458 shift_expression
2459 | relational_expression LT_TK shift_expression
2460 {
2463 }
2464 | relational_expression GT_TK shift_expression
2465 {
2468 }
2469 | relational_expression LTE_TK shift_expression
2470 {
2473 }
2474 | relational_expression GTE_TK shift_expression
2475 {
2478 }
2479 | relational_expression INSTANCEOF_TK reference_type
2481 | relational_expression LT_TK error
2483 | relational_expression GT_TK error
2485 | relational_expression LTE_TK error
2487 | relational_expression GTE_TK error
2489 | relational_expression INSTANCEOF_TK error
2491 ;
2493 equality_expression:
2494 relational_expression
2495 | equality_expression EQ_TK relational_expression
2496 {
2499 }
2500 | equality_expression NEQ_TK relational_expression
2501 {
2504 }
2505 | equality_expression EQ_TK error
2507 | equality_expression NEQ_TK error
2509 ;
2511 and_expression:
2512 equality_expression
2513 | and_expression AND_TK equality_expression
2514 {
2517 }
2518 | and_expression AND_TK error
2520 ;
2522 exclusive_or_expression:
2523 and_expression
2524 | exclusive_or_expression XOR_TK and_expression
2525 {
2528 }
2529 | exclusive_or_expression XOR_TK error
2531 ;
2533 inclusive_or_expression:
2534 exclusive_or_expression
2535 | inclusive_or_expression OR_TK exclusive_or_expression
2536 {
2539 }
2540 | inclusive_or_expression OR_TK error
2542 ;
2544 conditional_and_expression:
2545 inclusive_or_expression
2546 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2547 {
2550 }
2551 | conditional_and_expression BOOL_AND_TK error
2553 ;
2555 conditional_or_expression:
2556 conditional_and_expression
2557 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2558 {
2561 }
2562 | conditional_or_expression BOOL_OR_TK error
2564 ;
2567 conditional_or_expression
2568 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2569 {
2572 }
2573 | conditional_or_expression REL_QM_TK REL_CL_TK error
2574 {
2575 YYERROR_NOW;
2578 }
2579 | conditional_or_expression REL_QM_TK error
2581 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2583 ;
2585 assignment_expression:
2586 conditional_expression
2587 | assignment
2588 ;
2590 assignment:
2591 left_hand_side assignment_operator assignment_expression
2593 | left_hand_side assignment_operator error
2594 {
2597 }
2598 ;
2600 left_hand_side:
2601 name
2602 | field_access
2603 | array_access
2604 ;
2606 assignment_operator:
2607 ASSIGN_ANY_TK
2608 | ASSIGN_TK
2609 ;
2611 expression:
2612 assignment_expression
2613 ;
2615 constant_expression:
2616 expression
2617 ;
2619 %%
2621 /* Helper function to retrieve an OSB count. Should be used when the
2622 `dims:' rule is being used. */
2624 static int
2627 {
2631 abort ();
2636 return to_return;
2637 }
2639 \f
2641 /* This section of the code deal with save/restoring parser contexts.
2642 Add mode documentation here. FIXME */
2644 /* Helper function. Create a new parser context. With
2645 COPY_FROM_PREVIOUS set to a non zero value, content of the previous
2646 context is copied, otherwise, the new context is zeroed. The newly
2647 created context becomes the current one. */
2649 static void
2652 {
2657 {
2660 }
2661 else
2666 }
2668 /* Create a new parser context and make it the current one. */
2670 void
2671 java_push_parser_context ()
2672 {
2674 }
2676 void
2679 {
2680 tree current;
2684 return;
2689 {
2692 }
2694 /* If the old and new lexers differ, then free the old one. */
2698 /* Set the single import class file flag to 0 for the current list
2699 of imported things */
2703 /* And restore those of the previous context */
2708 /* If we pushed a context to parse a class intended to be generated,
2709 we keep it so we can remember the class. What we could actually
2710 do is to just update a list of class names. */
2712 {
2715 }
2716 else
2718 }
2720 /* Create a parser context for the use of saving some global
2721 variables. */
2723 void
2724 java_parser_context_save_global ()
2725 {
2727 {
2728 java_push_parser_context ();
2730 }
2732 /* If this context already stores data, create a new one suitable
2733 for data storage. */
2742 }
2744 /* Restore some global variables from the previous context. Make the
2745 previous context the current one. */
2747 void
2748 java_parser_context_restore_global ()
2749 {
2754 {
2755 tree s;
2758 }
2763 }
2765 /* Suspend vital data for the current class/function being parsed so
2766 that an other class can be parsed. Used to let local/anonymous
2767 classes be parsed. */
2769 static void
2770 java_parser_context_suspend ()
2771 {
2772 /* This makes debugging through java_debug_context easier */
2775 /* Duplicate the previous context, use it to save the globals we're
2776 interested in */
2781 /* Then create a new context which inherits all data from the
2782 previous one. This will be the new current context */
2785 /* Help debugging */
2787 }
2789 /* Resume vital data for the current class/function being parsed so
2790 that an other class can be parsed. Used to let local/anonymous
2791 classes be parsed. The trick is the data storing file position
2792 informations must be restored to their current value, so parsing
2793 can resume as if no context was ever saved. */
2795 static void
2796 java_parser_context_resume ()
2797 {
2802 /* We need to inherit the list of classes to complete/generate */
2806 /* Restore the current class and function from the saver */
2810 /* Retrive the restored context */
2813 /* Re-installed the data for the parsing to carry on */
2817 /* Buffer context can now be discarded */
2820 }
2822 /* Add a new anchor node to which all statement(s) initializing static
2823 and non static initialized upon declaration field(s) will be
2824 linked. */
2826 static void
2827 java_parser_context_push_initialized_field ()
2828 {
2829 tree node;
2842 }
2844 /* Pop the lists of initialized field. If this lists aren't empty,
2845 remember them so we can use it to create and populate the finit$
2846 or <clinit> functions. */
2848 static void
2849 java_parser_context_pop_initialized_field ()
2850 {
2851 tree stmts;
2855 {
2860 }
2863 {
2867 /* Keep initialization in order to enforce 8.5 */
2870 }
2872 /* JDK 1.1 instance initializers */
2874 {
2880 }
2881 }
2883 static tree
2885 tree list;
2886 {
2887 /* We have to keep things in order. The alias initializer have to
2888 come first, then the initialized regular field, in reverse to
2889 keep them in lexical order. */
2894 break;
2896 /* No static initialized, the list is fine as is */
2900 /* No marker? reverse the whole list */
2904 /* Otherwise, reverse what's after the marker and the new reordered
2905 sublist will replace the marker. */
2906 else
2907 {
2911 }
2912 return list;
2913 }
2915 /* Helper functions to dump the parser context stack. */
2917 #define TAB_CONTEXT(C) \
2920 static void
2923 {
2926 {
2943 }
2944 }
2946 /* Dump the stacked up parser contexts. Intended to be called from a
2947 debugger. */
2949 void
2950 java_debug_context ()
2951 {
2953 }
2955 \f
2957 /* Flag for the error report routine to issue the error the first time
2958 it's called (overriding the default behavior which is to drop the
2959 first invocation and honor the second one, taking advantage of a
2960 richer context. */
2963 /* Reporting an constructor invocation error. */
2964 static void
2965 parse_ctor_invocation_error ()
2966 {
2969 else
2971 }
2973 /* Reporting JDK1.1 features not implemented. */
2975 static tree
2978 {
2980 java_error_count++;
2981 return empty_stmt_node;
2982 }
2986 void
2989 {
2998 return;
3000 /* Save current error location but report latter, when the context is
3001 richer. */
3003 {
3006 /* Do something to use the previous line if we're reaching the
3007 end of the file... */
3008 #ifdef VERBOSE_SKELETON
3010 #endif
3011 return;
3012 }
3014 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3016 return;
3020 java_warning_count++;
3021 else
3022 java_error_count++;
3025 {
3028 }
3040 else
3043 /* This allow us to cheaply avoid an extra 'Invalid expression
3044 statement' error report when errors have been already reported on
3045 the same line. This occurs when we report an error but don't have
3046 a synchronization point other than ';', which
3047 expression_statement is the only one to take care of. */
3049 }
3051 static void
3053 tree cl;
3056 {
3066 /* We have a CL, that's a good reason for using it if it contains data */
3077 }
3079 /* Issue an error message at a current source line CL */
3081 void
3083 {
3084 #ifndef ANSI_PROTOTYPES
3085 tree cl;
3087 #endif
3091 #ifndef ANSI_PROTOTYPES
3094 #endif
3097 }
3099 /* Issue a warning at a current source line CL */
3101 static void
3103 {
3104 #ifndef ANSI_PROTOTYPES
3105 tree cl;
3107 #endif
3111 #ifndef ANSI_PROTOTYPES
3114 #endif
3120 }
3122 static tree
3124 tree node;
3125 {
3127 {
3129 tree to_return;
3132 {
3133 case BLOCK:
3135 continue;
3137 case COMPOUND_EXPR:
3140 return to_return;
3142 continue;
3144 case LOOP_EXPR:
3146 continue;
3148 case LABELED_BLOCK_EXPR:
3150 continue;
3152 default:
3156 return node;
3157 return NULL_TREE;
3158 }
3159 }
3160 return NULL_TREE;
3161 }
3163 /* Issue a missing return statement error. Uses METHOD to figure the
3164 last line of the method the error occurs in. */
3166 static void
3168 tree method;
3169 {
3172 }
3174 /* Issue an unreachable statement error. From NODE, find the next
3175 statement to report appropriately. */
3176 static void
3178 tree node;
3179 {
3180 /* Browse node to find the next expression node that has a WFL. Use
3181 the location to report the error */
3184 else
3188 {
3191 }
3192 else
3193 abort ();
3194 }
3196 int
3197 java_report_errors ()
3198 {
3207 return java_error_count;
3208 }
3213 {
3215 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3217 /* Access modifier looked-up first for easier report on forbidden
3218 access. */
3232 return buffer;
3233 #undef COPY_RETURN
3234 }
3236 /* Issuing error messages upon redefinition of classes, interfaces or
3237 variables. */
3239 static void
3243 {
3247 /* Here we should point out where its redefined. It's a unicode. FIXME */
3248 }
3250 static void
3254 {
3257 /* Figure a proper name for type. We might haven't resolved it */
3260 else
3267 }
3269 static tree
3272 {
3276 /* Eventually get more dims */
3279 more_dims++;
3281 /* If we have, then craft a new type for this variable */
3283 {
3288 /* If we have a pointer, use its type */
3292 /* Building the first dimension of a primitive type uses this
3293 function */
3295 {
3297 more_dims--;
3298 }
3299 /* Otherwise, if we have a WFL for this type, use it (the type
3300 is already an array on an unresolved type, and we just keep
3301 on adding dimensions) */
3303 {
3310 }
3312 /* Add all the dimensions */
3316 /* The type may have been incomplete in the first place */
3319 }
3323 return type;
3324 }
3326 /* Build something that the type identifier resolver will identify as
3327 being an array to an unresolved type. TYPE_WFL is a WFL on a
3328 identifier. */
3330 static tree
3332 tree type_or_wfl;
3333 {
3335 tree wfl;
3337 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3338 just create a array type */
3351 /* Re-install the existing qualifications so that the type can be
3352 resolved properly. */
3354 return wfl;
3355 }
3357 static void
3360 {
3364 }
3366 /* Bulk of common class/interface checks. Return 1 if an error was
3367 encountered. TAG is 0 for a class, 1 for an interface. */
3369 static int
3373 {
3374 tree node;
3385 /* Scope of an interface/class type name:
3386 - Can't be imported by a single type import
3387 - Can't already exists in the package */
3391 {
3392 parse_error_context
3397 }
3399 {
3403 }
3408 /* If public, file name should match class/interface name, except
3409 when dealing with an inner class */
3411 {
3414 /* Contains OS dependent assumption on path separator. FIXME */
3417 f--)
3418 ;
3420 f++;
3424 parse_error_context
3429 }
3431 /* Static classes can be declared only in top level classes. Note:
3432 once static, a inner class is a top level class. */
3434 {
3435 /* Catch the specific error of declaring an class inner class
3436 with no toplevel enclosing class. Prevent check_modifiers from
3437 complaining a second time */
3439 {
3440 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3443 }
3444 /* Else, in the context of a top-level class declaration, let
3445 `check_modifiers' do its job, otherwise, give it a go */
3446 else
3448 }
3450 /* Inner classes can be declared private or protected
3451 within their enclosing classes. */
3453 {
3454 /* A class which is local to a block can't be public, private,
3455 protected or static. But it is created final, so allow this
3456 one. */
3459 else
3460 {
3465 }
3466 }
3469 {
3472 else
3477 }
3478 else
3479 check_modifiers ((current_function_decl ?
3484 }
3486 static void
3488 tree cpc_list;
3489 {
3490 tree name;
3493 return;
3494 else
3497 /* Pick the qualified name when dealing with the first upmost
3498 enclosing class */
3503 /* Why is NO_DOLLAR_IN_LABEL defined? */
3504 #if 0
3505 #ifdef NO_DOLLAR_IN_LABEL
3507 #endif
3508 #endif
3510 }
3512 /* Can't redefine a class already defined in an earlier scope. */
3514 static int
3517 {
3518 tree scope_list;
3523 {
3524 parse_error_context
3525 (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",
3528 }
3530 }
3532 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3533 we remember ENCLOSING and SUPER. */
3535 static tree
3539 {
3544 {
3551 return decl;
3554 /* Explore enclosing contexts. */
3556 {
3559 return decl;
3560 }
3562 /* Now go to the upper classes, bail out if necessary. We will
3563 analyze the returned SUPER and act accordingly (see
3564 do_resolve_class.) */
3567 break;
3571 else
3574 /* We may not have checked for circular inheritance yet, so do so
3575 here to prevent an infinite loop. */
3578 {
3582 parse_error_context
3586 }
3587 else
3589 }
3591 /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3595 return NULL_TREE;
3596 }
3598 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3599 qualified. */
3601 static tree
3604 {
3607 return NULL_TREE;
3611 /* First search: within the scope of `enclosing', search for name */
3616 else
3620 return to_return;
3622 /* We're dealing with a qualified name. Try to resolve thing until
3623 we get something that is an enclosing class. */
3625 {
3630 {
3635 /* Don't try to resolve ACC as a class name if it follows
3636 the current package name. We don't want to pick something
3637 that's accidentally there: for example `a.b.c' in package
3638 `a.b' shouldn't trigger loading `a' if it's there by
3639 itself. */
3644 else
3646 }
3648 /* A NULL qual and a decl means that the search ended
3649 successfully?!? We have to do something then. FIXME */
3653 else
3655 }
3656 /* Otherwise, create a qual for the other part of the resolution. */
3657 else
3661 }
3663 /* We go inside the list of sub classes and try to find a way
3664 through. */
3666 static tree
3669 {
3671 return NULL_TREE;
3674 {
3677 tree inner_list;
3681 {
3683 {
3685 break;
3686 }
3687 }
3689 }
3692 }
3694 /* Reach all inner classes and tie their unqualified name to a
3695 DECL. */
3697 static void
3699 tree outer;
3701 {
3702 tree l;
3707 }
3709 static void
3710 link_nested_class_to_enclosing ()
3711 {
3713 {
3719 }
3720 }
3722 static tree
3724 tree name;
3725 {
3729 {
3737 }
3738 return id;
3739 }
3741 /* If DECL is NULL, create and push a new DECL, record the current
3742 line CL and do other maintenance things. */
3744 static tree
3747 {
3751 /* Take care of the file and line business */
3753 /* If we're emiting xrefs, store the line/col number information */
3756 else
3766 /* Link the declaration to the already seen ones */
3770 /* Create a new nodes in the global lists */
3774 /* Install a new dependency list element */
3779 return decl;
3780 }
3782 static void
3785 {
3786 tree node;
3787 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3788 takes care of ensuring that:
3789 - This is an accessible interface type,
3790 - Circularity detection.
3791 parser_add_interface is then called. If present but not defined,
3792 the check operation is delayed until the super interface gets
3793 defined. */
3795 {
3799 {
3802 }
3803 else
3806 }
3807 }
3809 /* Create an interface in pass1 and return its decl. Return the
3810 interface's decl in pass 2. */
3812 static tree
3816 {
3821 /* Certain syntax errors are making SUPER be like ID. Avoid this
3822 case. */
3828 /* Basic checks: scope, redefinition, modifiers */
3830 {
3831 PUSH_ERROR ();
3832 return NULL_TREE;
3833 }
3835 /* Suspend the current parsing context if we're parsing an inner
3836 interface */
3838 {
3839 java_parser_context_suspend ();
3840 /* Interface members are public. */
3843 }
3845 /* Push a new context for (static) initialized upon declaration fields */
3846 java_parser_context_push_initialized_field ();
3848 /* Interface modifiers check
3849 - public/abstract allowed (already done at that point)
3850 - abstract is obsolete (comes first, it's a warning, or should be)
3851 - Can't use twice the same (checked in the modifier rule) */
3853 parse_warning_context
3855 "Redundant use of `abstract' modifier. Interface `%s' is implicitely abstract", IDENTIFIER_POINTER (raw_name));
3857 /* Create a new decl if DECL is NULL, otherwise fix it */
3860 /* Set super info and mark the class a complete */
3867 return decl;
3868 }
3870 /* Anonymous class counter. Will be reset to 1 every time a non
3871 anonymous class gets created. */
3874 /* Patch anonymous class CLASS, by either extending or implementing
3875 DEP. */
3877 static void
3880 {
3885 /* If it's an interface, implement it */
3887 {
3888 tree s_binfo;
3892 return;
3898 /* And add the interface */
3900 }
3901 /* Otherwise, it's a type we want to extend */
3902 else
3903 {
3905 return;
3907 }
3908 }
3910 static tree
3913 tree type_name;
3914 {
3919 /* The unqualified name of the anonymous class. It's just a number. */
3924 /* We know about the type to extend/implement. We go ahead */
3926 {
3927 /* Create a class which either implements on extends the designated
3928 class. The class bears an innacessible name. */
3930 {
3931 /* It's OK to modify it here. It's been already used and
3932 shouldn't be reused */
3934 /* Interfaces should presented as a list of WFLs */
3936 }
3937 else
3939 }
3943 /* We didn't know anything about the stuff. We register a dependence. */
3948 return class;
3949 }
3951 /* Create a class in pass1 and return its decl. Return class
3952 interface's decl in pass 2. */
3954 static tree
3958 {
3961 tree super_decl_type;
3963 /* Certain syntax errors are making SUPER be like ID. Avoid this
3964 case. */
3972 /* Basic check: scope, redefinition, modifiers */
3974 {
3975 PUSH_ERROR ();
3976 return NULL_TREE;
3977 }
3979 /* Suspend the current parsing context if we're parsing an inner
3980 class or an anonymous class. */
3982 {
3983 java_parser_context_suspend ();
3984 /* Interface members are public. */
3987 }
3989 /* Push a new context for (static) initialized upon declaration fields */
3990 java_parser_context_push_initialized_field ();
3992 /* Class modifier check:
3993 - Allowed modifier (already done at that point)
3994 - abstract AND final forbidden
3995 - Public classes defined in the correct file */
3997 parse_error_context
4001 /* Create a new decl if DECL is NULL, otherwise fix it */
4004 /* If SUPER exists, use it, otherwise use Object */
4006 {
4007 /* Can't extend java.lang.Object */
4009 {
4011 return NULL_TREE;
4012 }
4014 super_decl_type =
4016 }
4019 /* We're defining java.lang.Object */
4020 else
4023 /* A class nested in an interface is implicitly static. */
4026 {
4028 }
4030 /* Set super info and mark the class as complete. */
4037 /* Add the private this$<n> field, Replicate final locals still in
4038 scope as private final fields mangled like val$<local_name>.
4039 This doesn't not occur for top level (static) inner classes. */
4043 /* If doing xref, store the location at which the inherited class
4044 (if any) was seen. */
4048 /* Eventually sets the @deprecated tag flag */
4051 /* Reset the anonymous class counter when declaring non inner classes */
4055 return decl;
4056 }
4058 /* End a class declaration: register the statements used to create
4059 finit$ and <clinit>, pop the current class and resume the prior
4060 parser context if necessary. */
4062 static void
4065 {
4066 /* If an error occured, context weren't pushed and won't need to be
4067 popped by a resume. */
4070 java_parser_context_pop_initialized_field ();
4071 POP_CPC ();
4073 java_parser_context_resume ();
4075 /* We're ending a class declaration, this is a good time to reset
4076 the interface cout. Note that might have been already done in
4077 create_interface, but if at that time an inner class was being
4078 dealt with, the interface count was reset in a context created
4079 for the sake of handling inner classes declaration. */
4081 }
4083 static void
4085 tree class_decl;
4086 tree fct_decl;
4087 {
4093 ACC_PRIVATE);
4097 return;
4101 {
4102 tree decl;
4104 {
4108 /* Avoid non final arguments. */
4110 continue;
4116 /* Build an initialization for the field: it will be
4117 initialized by a parameter added to finit$, bearing a
4118 mangled name of the field itself (param$<n>.) The
4119 parameter is provided to finit$ by the constructor
4120 invoking it (hence the constructor will also feature a
4121 hidden parameter, set to the value of the outer context
4122 local at the time the inner class is created.)
4124 Note: we take into account all possible locals that can
4125 be accessed by the inner class. It's actually not trivial
4126 to minimize these aliases down to the ones really
4127 used. One way to do that would be to expand all regular
4128 methods first, then finit$ to get a picture of what's
4129 used. It works with the exception that we would have to
4130 go back on all constructor invoked in regular methods to
4131 have their invokation reworked (to include the right amount
4132 of alias initializer parameters.)
4134 The only real way around, I think, is a first pass to
4135 identify locals really used in the inner class. We leave
4136 the flag FIELD_LOCAL_ALIAS_USED around for that future
4137 use.
4139 On the other hand, it only affect local inner classes,
4140 whose constructors (and finit$ call) will be featuring
4141 unecessary arguments. It's easy for a developper to keep
4142 this number of parameter down by using the `final'
4143 keyword only when necessary. For the time being, we can
4144 issue a warning on unecessary finals. FIXME */
4148 /* Register the field. The TREE_LIST holding the part
4149 initialized/initializer will be marked ARG_FINAL_P so
4150 that the created field can be marked
4151 FIELD_LOCAL_ALIAS. */
4155 }
4156 }
4159 return;
4161 /* If we ever registered an alias field, insert and marker to
4162 remeber where the list ends. The second part of the list (the one
4163 featuring initialized fields) so it can be later reversed to
4164 enforce 8.5. The marker will be removed during that operation. */
4168 }
4170 /* Can't use lookup_field () since we don't want to load the class and
4171 can't set the CLASS_LOADED_P flag */
4173 static tree
4175 tree class;
4176 tree name;
4177 {
4178 tree decl;
4180 {
4182 return decl;
4183 }
4184 return NULL_TREE;
4185 }
4187 /* Wrap around lookup_field that doesn't potentially upset the value
4188 of CLASS */
4190 static tree
4193 {
4196 java_parser_context_save_global ();
4198 /* Last chance: if we're within the context of an inner class, we
4199 might be trying to access a local variable defined in an outer
4200 context. We try to look for it now. */
4202 {
4203 tree new_name;
4208 }
4210 {
4213 }
4215 java_parser_context_restore_global ();
4217 }
4219 /* Find duplicate field within the same class declarations and report
4220 the error. Returns 1 if a duplicated field was found, 0
4221 otherwise. */
4223 static int
4226 {
4227 /* This might be modified to work with method decl as well */
4230 {
4236 /* The type may not have been completed by the time we report
4237 the error */
4243 parse_error_context
4251 }
4253 }
4255 /* Field registration routine. If TYPE doesn't exist, field
4256 declarations are linked to the undefined TYPE dependency list, to
4257 be later resolved in java_complete_class () */
4259 static void
4263 {
4274 return;
4276 /* If we're adding fields to interfaces, those fields are public,
4277 static, final */
4279 {
4287 INTERFACE_FIELD_MODIFIERS);
4289 }
4291 /* Obtain a suitable type for resolution, if necessary */
4294 /* If TYPE is fully resolved and we don't have a reference, make one */
4299 {
4300 tree real_type;
4301 tree field_decl;
4306 /* Can't declare non-final static fields in inner classes */
4309 parse_error_context
4314 /* Process NAME, as it may specify extra dimension(s) for it */
4317 /* Type adjustment. We may have just readjusted TYPE because
4318 the variable specified more dimensions. Make sure we have
4319 a reference if we can and don't have one already. Also
4320 change the name if we have an init. */
4322 {
4326 }
4329 /* Check for redeclarations */
4331 continue;
4333 /* Set lineno to the line the field was found and create a
4334 declaration for it. Eventually sets the @deprecated tag flag. */
4337 else
4342 /* If the field denotes a final instance variable, then we
4343 allocate a LANG_DECL_SPECIFIC part to keep track of its
4344 initialization. We also mark whether the field was
4345 initialized upon it's declaration. We don't do that if the
4346 created field is an alias to a final local. */
4348 {
4353 }
4355 /* If the couple initializer/initialized is marked ARG_FINAL_P,
4356 we mark the created field FIELD_LOCAL_ALIAS, so that we can
4357 hide parameters to this inner class finit$ and
4358 constructors. It also means that the field isn't final per
4359 say. */
4361 {
4364 }
4366 /* Check if we must chain. */
4370 /* If we have an initialization value tied to the field */
4372 {
4373 /* The field is declared static */
4375 {
4376 /* We include the field and its initialization part into
4377 a list used to generate <clinit>. After <clinit> is
4378 walked, field initializations will be processed and
4379 fields initialized with known constants will be taken
4380 out of <clinit> and have their DECL_INITIAL set
4381 appropriately. */
4387 }
4388 /* A non-static field declared with an immediate initialization is
4389 to be initialized in <init>, if any. This field is remembered
4390 to be processed at the time of the generation of <init>. */
4391 else
4392 {
4395 }
4398 }
4399 }
4401 }
4403 /* Generate finit$, using the list of initialized fields to populate
4404 its body. finit$'s parameter(s) list is adjusted to include the
4405 one(s) used to initialized the field(s) caching outer context
4406 local(s). */
4408 static tree
4410 tree class_type;
4411 {
4431 current));
4433 return mdecl;
4434 }
4436 /* Generate a function to run the instance initialization code. The
4437 private method is called `instinit$'. Unless we're dealing with an
4438 anonymous class, we determine whether all ctors of CLASS_TYPE
4439 declare a checked exception in their `throws' clause in order to
4440 see whether it's necessary to encapsulate the instance initializer
4441 statements in a try/catch/rethrow sequence. */
4443 static tree
4445 tree class_type;
4446 {
4447 tree current;
4452 void_type_node,
4458 /* Gather all the statements in a compound */
4463 /* We need to encapsulate COMPOUND by a try/catch statement to
4464 rethrow exceptions that might occur in the instance initializer.
4465 We do that only if all ctors of CLASS_TYPE are set to catch a
4466 checked exception. This doesn't apply to anonymous classes (since
4467 they don't have declared ctors.) */
4470 {
4475 exception_type_node);
4476 }
4482 return mdecl;
4483 }
4485 /* FIXME */
4486 static tree
4488 tree class_type;
4489 {
4493 {
4496 to_return =
4498 parm);
4499 }
4500 return to_return;
4501 }
4503 /* Shared accros method_declarator and method_header to remember the
4504 patch stage that was reached during the declaration of the method.
4505 A method DECL is built differently is there is no patch
4506 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4507 pending on the currently defined method. */
4511 /* Check the method declaration and add the method to its current
4512 class. If the argument list is known to contain incomplete types,
4513 the method is partially added and the registration will be resume
4514 once the method arguments resolved. If TYPE is NULL, we're dealing
4515 with a constructor. */
4517 static tree
4521 {
4531 return error_mark_node;
4541 return NULL_TREE;
4543 /* There are some forbidden modifiers for an abstract method and its
4544 class must be abstract as well. */
4546 {
4554 parse_error_context
4558 }
4560 /* Things to be checked when declaring a constructor */
4562 {
4564 /* 8.6: Constructor declarations: we might be trying to define a
4565 method without specifying a return type. */
4567 parse_error_context
4569 /* 8.6.3: Constructor modifiers */
4570 else
4571 {
4577 }
4578 /* If we found error here, we don't consider it's OK to tread
4579 the method definition as a constructor, for the rest of this
4580 function */
4583 }
4585 /* Method declared within the scope of an interface are implicitly
4586 abstract and public. Conflicts with other erroneously provided
4587 modifiers are checked right after. */
4590 {
4591 /* If FLAGS isn't set because of a modifier, turn the
4592 corresponding modifier WFL to NULL so we issue a warning on
4593 the obsolete use of the modifier */
4600 }
4602 /* Inner class can't declare static methods */
4604 {
4605 parse_error_context
4606 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4609 }
4611 /* Modifiers context reset moved up, so abstract method declaration
4612 modifiers can be later checked. */
4614 /* Set constructor returned type to void and method name to <init>,
4615 unless we found an error identifier the constructor (in which
4616 case we retain the original name) */
4618 {
4622 }
4623 else
4626 /* Do the returned type resolution and registration if necessary */
4635 {
4639 }
4640 else
4644 /* When defining an abstract or interface method, the curly
4645 bracket at level 1 doesn't exist because there is no function
4646 body */
4650 /* Remember the original argument list */
4654 {
4657 /* Patch for the return type */
4659 {
4662 }
4663 /* This is the stop JDEP. METH allows the function's signature
4664 to be computed. */
4666 }
4667 else
4671 /* Remember final parameters */
4674 /* Fix the method argument list so we have the argument name
4675 information */
4678 /* Register the parameter number and re-install the current line
4679 number */
4683 /* Register exception specified by the `throws' keyword for
4684 resolution and set the method decl appropriate field to the list.
4685 Note: the grammar ensures that what we get here are class
4686 types. */
4688 {
4691 {
4696 }
4698 }
4703 /* Set the flag if we correctly processed a constructor */
4705 {
4707 /* Compute and store the number of artificial parameters declared
4708 for this constructor */
4712 count++;
4714 }
4716 /* Eventually set the @deprecated tag flag */
4719 /* If doing xref, store column and line number information instead
4720 of the line number only. */
4724 return meth;
4725 }
4727 static void
4730 {
4733 {
4736 }
4738 {
4742 }
4743 }
4745 /* Complete the method declaration with METHOD_BODY. */
4747 static void
4749 tree method_body;
4750 {
4754 return;
4758 /* 8.4.5 Method Body */
4760 {
4768 }
4770 {
4772 parse_error_context
4777 }
4786 maybe_absorb_scoping_blocks ();
4787 /* Exit function's body */
4788 exit_block ();
4789 /* Merge last line of the function with first line, directly in the
4790 function decl. It will be used to emit correct debug info. */
4794 /* Since function's argument's list are shared, reset the
4795 ARG_FINAL_P parameter that might have been set on some of this
4796 function parameters. */
4799 /* So we don't have an irrelevant function declaration context for
4800 the next static block we'll see. */
4802 }
4804 /* Build a an error message for constructor circularity errors. */
4809 {
4815 }
4817 /* Verify a circular call to METH. Return 1 if an error is found, 0
4818 otherwise. */
4820 static int
4823 {
4826 tree c;
4828 /* If we haven't already registered LIST with the garbage collector,
4829 do so now. */
4831 {
4834 }
4837 {
4839 {
4842 {
4843 tree liste;
4846 {
4847 parse_error_context
4849 constructor_circularity_msg
4851 java_error_count--;
4852 }
4853 }
4861 }
4862 }
4864 {
4869 }
4871 }
4873 /* Check modifiers that can be declared but exclusively */
4875 static void
4878 {
4886 parse_error_context
4887 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4896 }
4898 /* Check the methode header METH for abstract specifics features */
4900 static void
4902 tree meth;
4903 {
4915 }
4917 /* Create a FUNCTION_TYPE node and start augmenting it with the
4918 declared function arguments. Arguments type that can't be resolved
4919 are left as they are, but the returned node is marked as containing
4920 incomplete types. */
4922 static tree
4925 {
4933 return error_mark_node;
4935 /* If we're dealing with an inner class constructor, we hide the
4936 this$<n> decl in the name field of its parameter declaration. We
4937 also might have to hide the outer context local alias
4938 initializers. Not done when the class is a toplevel class. */
4941 {
4943 /* First the aliases, linked to the regular parameters */
4944 aliases_list =
4950 /* Then this$<n> */
4954 list);
4955 }
4958 {
4965 tree real_type;
4967 /* Obtain a suitable type for resolution, if necessary */
4970 /* Process NAME, as it may specify extra dimension(s) for it */
4976 {
4980 }
4982 /* Check redefinition */
4985 {
4986 parse_error_context
4990 break;
4991 }
4993 /* If we've an incomplete argument type, we know there is a location
4994 to patch when the type get resolved, later. */
4997 {
5003 }
5005 /* The argument node: a name and a (possibly) incomplete type. */
5007 /* Remeber arguments declared final. */
5014 }
5017 return node;
5018 }
5020 static int
5022 tree wfl;
5025 {
5027 {
5029 {
5035 else
5037 }
5039 }
5043 }
5045 /* From NAME, build a qualified identifier node using the
5046 qualification from the current package definition. */
5048 static tree
5050 tree name;
5051 {
5052 tree nested_class_name;
5055 return nested_class_name;
5059 else
5060 return name;
5061 }
5063 /* Called once the type a interface extends is resolved. Returns 0 if
5064 everything is OK. */
5066 static int
5069 {
5072 /* Has to be an interface */
5074 {
5075 parse_error_context
5083 }
5085 /* Check top-level interface access. Inner classes are subject to member
5086 access rules (6.6.1). */
5095 }
5097 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5098 0 if everthing is OK. */
5100 static int
5103 {
5106 /* SUPER should be a CLASS (neither an array nor an interface) */
5108 {
5109 parse_error_context
5115 }
5118 {
5122 }
5124 /* Check top-level class scope. Inner classes are subject to member access
5125 rules (6.6.1). */
5134 }
5136 /* Create a new dependency list and link it (in a LIFO manner) to the
5137 CTXP list of type dependency list. */
5139 static void
5142 {
5147 }
5152 {
5155 {
5159 }
5160 return prev;
5161 }
5163 /* Create a fake pointer based on the ID stored in
5164 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5165 registered again. */
5167 static tree
5169 tree type_name;
5170 {
5177 else
5178 abort ();
5183 return ptr;
5184 }
5186 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5187 non NULL instead of computing a new fake type based on WFL. The new
5188 dependency is inserted in the current type dependency list, in FIFO
5189 manner. */
5191 static tree
5195 {
5207 /* For some dependencies, set the enclosing class of the current
5208 class to be the enclosing context */
5213 else
5219 return ptr;
5220 }
5222 void
5223 java_check_circular_reference ()
5224 {
5225 tree current;
5227 {
5230 {
5231 /* Check all interfaces this class extends */
5236 return;
5239 {
5245 }
5246 }
5247 else
5251 (cyclic_inheritance_report ?
5253 }
5254 }
5256 /* Augment the parameter list PARM with parameters crafted to
5257 initialize outer context locals aliases. Through ARTIFICIAL, a
5258 count is kept of the number of crafted parameters. MODE governs
5259 what eventually gets created: something suitable for a function
5260 creation or a function invocation, either the constructor or
5261 finit$. */
5263 static tree
5268 {
5269 tree field;
5274 {
5277 tree mangled_id;
5280 {
5281 case AIPL_FUNCTION_DECLARATION:
5287 else
5289 break;
5291 case AIPL_FUNCTION_CREATION:
5295 break;
5297 case AIPL_FUNCTION_FINIT_INVOCATION:
5300 /* Now, this is wrong. purpose should always be the NAME
5301 of something and value its matching value (decl, type,
5302 etc...) FIXME -- but there is a lot to fix. */
5304 /* When invoked for this kind of operation, we already
5305 know whether a field is used or not. */
5308 break;
5310 case AIPL_FUNCTION_CTOR_INVOCATION:
5311 /* There are two case: the constructor invokation happends
5312 outside the local inner, in which case, locales from the outer
5313 context are directly used.
5315 Otherwise, we fold to using the alias directly. */
5318 else
5319 {
5322 }
5323 break;
5324 }
5328 }
5330 {
5335 }
5337 return parm;
5338 }
5340 /* Craft a constructor for CLASS_DECL -- what we should do when none
5341 where found. ARGS is non NULL when a special signature must be
5342 enforced. This is the case for anonymous classes. */
5344 static void
5347 {
5356 /* The constructor name is <init> unless we're dealing with an
5357 anonymous class, in which case the name will be fixed after having
5358 be expanded. */
5361 else
5364 /* If we're dealing with an inner class constructor, we hide the
5365 this$<n> decl in the name field of its parameter declaration. */
5367 {
5372 /* Some more arguments to be hidden here. The values of the local
5373 variables of the outer context that the inner class needs to see. */
5377 }
5379 /* Then if there are any args to be enforced, enforce them now */
5381 {
5384 }
5390 /* Now, mark the artificial parameters. */
5393 }
5396 /* Fix the constructors. This will be called right after circular
5397 references have been checked. It is necessary to fix constructors
5398 early even if no code generation will take place for that class:
5399 some generated constructor might be required by the class whose
5400 compilation triggered this one to be simply loaded. */
5402 void
5403 java_fix_constructors ()
5404 {
5405 tree current;
5408 {
5411 tree decl;
5414 continue;
5418 {
5420 {
5423 }
5424 }
5426 /* Anonymous class constructor can't be generated that early. */
5429 }
5430 }
5432 /* safe_layout_class just makes sure that we can load a class without
5433 disrupting the current_class, input_file, lineno, etc, information
5434 about the class processed currently. */
5436 void
5438 tree class;
5439 {
5449 }
5451 static tree
5454 {
5455 tree decl;
5459 else
5460 {
5464 }
5469 {
5472 {
5476 }
5478 }
5479 return decl;
5480 }
5482 /* Complete unsatisfied class declaration and their dependencies */
5484 void
5485 java_complete_class ()
5486 {
5487 tree cclass;
5490 tree type;
5492 /* Process imports */
5493 process_imports ();
5495 /* Rever things so we have the right order */
5502 {
5505 {
5506 tree decl;
5508 continue;
5510 /* Now it's time to patch */
5512 {
5513 case JDEP_SUPER:
5514 /* Simply patch super */
5516 continue;
5519 break;
5521 case JDEP_FIELD:
5522 {
5523 /* We do part of the job done in add_field */
5532 SOURCE_FRONTEND_DEBUG
5536 break;
5537 }
5539 case JDEP_METHOD_RETURN:
5542 {
5544 {
5549 SOURCE_FRONTEND_DEBUG
5553 IDENTIFIER_POINTER (EXPR_WFL_NODE
5556 }
5557 else
5561 break;
5562 else
5564 }
5566 {
5568 /* Recompute and reset the signature, check first that
5569 all types are now defined. If they're not,
5570 dont build the signature. */
5572 {
5575 }
5576 }
5577 else
5578 continue;
5579 break;
5581 case JDEP_INTERFACE:
5584 continue;
5586 break;
5588 case JDEP_PARM:
5589 case JDEP_VARIABLE:
5594 break;
5596 case JDEP_TYPE:
5598 SOURCE_FRONTEND_DEBUG
5601 break;
5603 case JDEP_EXCEPTION:
5605 SOURCE_FRONTEND_DEBUG
5608 break;
5610 case JDEP_ANONYMOUS:
5612 break;
5614 default:
5615 abort ();
5616 }
5617 }
5618 }
5619 return;
5620 }
5622 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5623 array. */
5625 static tree
5628 {
5632 tree resolved_type_decl;
5635 {
5639 {
5642 resolved_type);
5643 }
5644 return resolved_type_decl;
5645 }
5647 /* 1- Check to see if we have an array. If true, find what we really
5648 want to resolve */
5650 name++;
5652 {
5655 }
5657 /* 2- Resolve the bare type */
5660 return NULL_TREE;
5663 /* 3- If we have and array, reconstruct the array down to its nesting */
5665 {
5667 {
5669 name--;
5670 }
5671 /* A TYPE_NAME that is a TYPE_DECL was set in
5672 build_java_array_type, return it. */
5674 }
5676 return resolved_type_decl;
5677 }
5679 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5680 are used to report error messages. Do not try to replace TYPE_NAME
5681 (class_type) by a variable, since it is changed by
5682 find_in_imports{_on_demand} and (but it doesn't really matter)
5683 qualify_and_find. */
5685 tree
5688 {
5692 /* This hash table is used to register the classes we're going
5693 through when searching the current class as an inner class, in
5694 order to detect circular references. Remember to free it before
5695 returning the section 0- of this function. */
5699 /* 0- Search in the current class as an inner class.
5700 Maybe some code here should be added to load the class or
5701 something, at least if the class isn't an inner class and ended
5702 being loaded from class file. FIXME. */
5704 {
5708 break;
5710 /* If we haven't found anything because SUPER reached Object and
5711 ENCLOSING happens to be an innerclass, try the enclosing context. */
5715 else
5717 }
5722 return new_class_decl;
5724 /* 1- Check for the type in single imports. This will change
5725 TYPE_NAME() if something relevant is found */
5728 /* 2- And check for the type in the current compilation unit */
5730 {
5735 }
5737 /* 3- Search according to the current package definition */
5739 {
5742 return new_class_decl;
5743 }
5745 /* 4- Check the import on demands. Don't allow bar.baz to be
5746 imported from foo.* */
5749 return NULL_TREE;
5751 /* If found in find_in_imports_on_demant, the type has already been
5752 loaded. */
5754 return new_class_decl;
5756 /* 5- Try with a name qualified with the package name we've seen so far */
5758 {
5759 tree package;
5761 /* If there is a current package (ctxp->package), it's the first
5762 element of package_list and we can skip it. */
5769 return new_class_decl;
5770 }
5772 /* 5- Check an other compilation unit that bears the name of type */
5778 /* If we don't have a value for CL, then we're being called recursively.
5779 We can't check package access just yet, but it will be taken care of
5780 by the caller. */
5782 {
5784 return NULL_TREE;
5785 }
5787 /* 6- Last call for a resolution */
5789 }
5791 static tree
5794 {
5796 tree new_class_decl;
5801 {
5807 }
5808 return NULL_TREE;
5809 }
5811 /* Resolve NAME and lay it out (if not done and if not the current
5812 parsed class). Return a decl node. This function is meant to be
5813 called when type resolution is necessary during the walk pass. */
5815 static tree
5817 tree something;
5818 tree cl;
5819 {
5822 /* Don't do that on the current class */
5826 /* Don't do anything for void and other primitive types */
5828 return NULL_TREE;
5830 /* Pointer types can be reall pointer types or fake pointers. When
5831 finding a real pointer, recheck for primitive types */
5833 {
5835 {
5838 return NULL_TREE;
5839 }
5840 else
5842 }
5844 /* Don't do anything for arrays of primitive types */
5847 return NULL_TREE;
5849 /* Something might be a WFL */
5853 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5854 TYPE_DECL or a real TYPE */
5860 return NULL_TREE;
5862 /* Resolve and layout if necessary */
5865 /* Check methods */
5868 /* Layout the type if necessary */
5872 return decl;
5873 }
5875 /* Resolve a class, returns its decl but doesn't perform any
5876 layout. The current parsing context is saved and restored */
5878 static tree
5881 {
5884 java_parser_context_save_global ();
5886 java_parser_context_restore_global ();
5888 return decl;
5889 }
5891 /* Called when reporting errors. Skip leader '[' in a complex array
5892 type description that failed to be resolved. */
5897 {
5899 name++;
5900 return name;
5901 }
5903 /* The type CURRENT refers to can't be found. We print error messages. */
5905 static void
5908 {
5912 return;
5916 {
5917 case JDEP_SUPER:
5918 parse_error_context
5922 break;
5923 case JDEP_FIELD:
5924 parse_error_context
5928 break;
5930 parse_error_context
5935 break;
5937 parse_error_context
5941 break;
5942 case JDEP_INTERFACE:
5943 parse_error_context
5948 break;
5949 case JDEP_VARIABLE:
5950 parse_error_context
5952 purify_type_name (IDENTIFIER_POINTER
5955 break;
5957 parse_error_context
5960 break;
5961 default:
5962 /* Fix for -Wall. Just break doing nothing. The error will be
5963 caught later */
5964 break;
5965 }
5966 }
5968 /* Return a static string containing the DECL prototype string. If
5969 DECL is a constructor, use the class name instead of the form
5970 <init> */
5974 tree decl;
5975 {
5980 {
5983 }
5989 return to_return;
5990 }
5992 /* Track method being redefined inside the same class. As a side
5993 effect, set DECL_NAME to an IDENTIFIER (prior entering this
5994 function it's a FWL, so we can track errors more accurately.) */
5996 static int
5999 {
6002 /* There's no need to verify <clinit> and finit$ and instinit$ */
6009 {
6011 break;
6015 {
6016 parse_error_context
6021 }
6022 }
6024 }
6026 /* Return 1 if check went ok, 0 otherwise. */
6027 static int
6031 {
6038 {
6044 continue;
6046 /* Now verify that somewhere in between TYPE and CLASS,
6047 abstract method METHOD gets a non abstract definition
6048 that is inherited by CLASS. */
6056 do {
6060 /* Method search */
6063 {
6074 {
6076 break;
6077 }
6078 }
6082 /* Report that abstract METHOD didn't find an implementation
6083 that CLASS can use. */
6085 {
6090 parse_error_context
6092 "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",
6102 }
6103 }
6106 {
6107 /* Check for implemented interfaces. */
6111 {
6114 }
6115 }
6117 return ok;
6118 }
6120 /* Check that CLASS_DECL somehow implements all inherited abstract
6121 methods. */
6123 static void
6125 tree class_decl;
6126 {
6132 return;
6134 /* Check for inherited types */
6136 do {
6141 /* Check for implemented interfaces. */
6144 {
6147 }
6148 }
6150 /* Check all the types method DECL uses and return 1 if all of them
6151 are now complete, 0 otherwise. This is used to check whether its
6152 safe to build a method signature or not. */
6154 static int
6156 tree decl;
6157 {
6159 tree args;
6172 }
6174 /* Visible interface to check methods contained in CLASS_DECL */
6176 void
6178 tree class_decl;
6179 {
6181 return;
6185 else
6189 }
6191 /* Check all the methods of CLASS_DECL. Methods are first completed
6192 then checked according to regular method existance rules. If no
6193 constructor for CLASS_DECL were encountered, then build its
6194 declaration. */
6196 static void
6198 tree class_decl;
6199 {
6201 tree method;
6204 tree mthrows;
6206 /* It is not necessary to check methods defined in java.lang.Object */
6208 return;
6213 /* Should take interfaces into account. FIXME */
6215 {
6216 tree sig;
6220 /* Check for redefinitions */
6222 continue;
6224 /* If we see one constructor a mark so we don't generate the
6225 default one. Also skip other verifications: constructors
6226 can't be inherited hence hiden or overriden */
6228 {
6230 continue;
6231 }
6233 /* We verify things thrown by the method. They must inherits from
6234 java.lang.Throwable */
6237 {
6239 parse_error_context
6240 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6241 IDENTIFIER_POINTER
6243 }
6248 /* Inner class can't declare static methods */
6250 {
6252 parse_error_context
6253 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6256 }
6258 /* Nothing overrides or it's a private method. */
6260 continue;
6262 {
6264 continue;
6265 }
6267 /* If `found' is declared in an interface, make sure the
6268 modifier matches. */
6272 {
6274 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6278 }
6280 /* Can't override a method with the same name and different return
6281 types. */
6283 {
6286 parse_error_context
6290 IDENTIFIER_POINTER
6293 }
6297 /* Can't override final. Can't override static. */
6299 {
6300 /* Static *can* override static */
6302 continue;
6303 parse_error_context
6309 IDENTIFIER_POINTER
6311 continue;
6312 }
6314 /* Static method can't override instance method. */
6316 {
6317 parse_error_context
6319 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
6321 IDENTIFIER_POINTER
6323 continue;
6324 }
6326 /* - Overriding/hiding public must be public
6327 - Overriding/hiding protected must be protected or public
6328 - If the overriden or hidden method has default (package)
6329 access, then the overriding or hiding method must not be
6330 private; otherwise, a compile-time error occurs. If
6331 `found' belongs to an interface, things have been already
6332 taken care of. */
6339 {
6340 parse_error_context
6342 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6345 IDENTIFIER_POINTER (DECL_NAME
6347 continue;
6348 }
6350 /* Overriding methods must have compatible `throws' clauses on checked
6351 exceptions, if any */
6354 /* Inheriting multiple methods with the same signature. FIXME */
6355 }
6360 /* Search for inherited abstract method not yet implemented in this
6361 class. */
6365 abort ();
6366 }
6368 /* Return a non zero value if the `throws' clause of METHOD (if any)
6369 is incompatible with the `throws' clause of FOUND (if any). */
6371 static void
6374 {
6377 /* Can't check these things with class loaded from bytecode. FIXME */
6379 return;
6383 {
6384 /* We don't verify unchecked expressions */
6386 continue;
6387 /* Checked expression must be compatible */
6391 break;
6393 {
6394 parse_error_context
6395 (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'",
6398 IDENTIFIER_POINTER
6400 }
6401 }
6402 }
6404 /* Check abstract method of interface INTERFACE */
6406 static void
6408 tree interface_decl;
6409 {
6415 {
6416 /* 2- Check for double definition inside the defining interface */
6418 continue;
6420 /* 3- Overriding is OK as far as we preserve the return type and
6421 the thrown exceptions (FIXME) */
6424 {
6427 parse_error_context
6431 IDENTIFIER_POINTER
6434 continue;
6435 }
6436 }
6438 /* 4- Inherited methods can't differ by their returned types */
6440 return;
6443 {
6447 continue;
6450 sub_interface_method;
6452 {
6454 sub_interface_method);
6456 {
6457 parse_error_context
6459 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6462 IDENTIFIER_POINTER
6465 IDENTIFIER_POINTER
6467 }
6468 }
6469 }
6470 }
6472 /* Lookup methods in interfaces using their name and partial
6473 signature. Return a matching method only if their types differ. */
6475 static tree
6478 {
6483 return NULL_TREE;
6487 {
6492 return to_return;
6493 }
6495 {
6496 to_return = lookup_java_interface_method2
6499 return to_return;
6500 }
6502 return NULL_TREE;
6503 }
6505 /* Lookup method using their name and partial signature. Return a
6506 matching method only if their types differ. */
6508 static tree
6512 {
6522 {
6525 {
6532 return method;
6533 }
6535 }
6536 return NULL_TREE;
6537 }
6539 /* Return the line that matches DECL line number, and try its best to
6540 position the column number. Used during error reports. */
6542 static tree
6544 tree decl;
6545 {
6550 return NULL_TREE;
6553 {
6556 }
6569 return cl;
6570 }
6572 /* Look for a simple name in the single-type import list */
6574 static tree
6576 tree name;
6577 {
6578 tree node;
6584 return NULL_TREE;
6585 }
6587 /* Process all single-type import. */
6589 static int
6590 process_imports ()
6591 {
6592 tree import;
6596 {
6605 /* Don't load twice something already defined. */
6607 continue;
6610 {
6611 tree left;
6615 error_found =
6618 /* We found it, we can bail out */
6620 break;
6622 /* We haven't found it. Maybe we're trying to access an
6623 inner class. The only way for us to know is to try again
6624 after having dropped a qualifier. If we can't break it further,
6625 we have an error. */
6627 break;
6630 }
6632 {
6635 original_name);
6637 }
6642 }
6644 }
6646 /* Possibly find and mark a class imported by a single-type import
6647 statement. */
6649 static void
6651 tree class_type;
6652 {
6653 tree import;
6657 {
6660 }
6661 }
6663 static int
6667 {
6668 tree node;
6673 else
6679 }
6681 /* Read a import directory, gathering potential match for further type
6682 references. Indifferently reads a filesystem or a ZIP archive
6683 directory. */
6685 static void
6687 tree wfl;
6688 {
6702 return;
6709 {
6713 {
6721 else
6722 {
6726 {
6729 }
6733 {
6740 continue;
6742 current_entry_len);
6743 }
6744 }
6745 }
6746 else
6747 {
6753 {
6756 }
6761 continue;
6763 for (;;)
6764 {
6769 break;
6776 }
6779 }
6780 }
6784 /* Here we should have a unified way of retrieving an entry, to be
6785 indexed. */
6787 {
6790 {
6791 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
6792 java_error_count++;
6794 }
6795 else
6797 package_name);
6799 return;
6800 }
6802 }
6804 /* Possibly find a type in the import on demands specified
6805 types. Returns 1 if an error occured, 0 otherwise. Run throught the
6806 entire list, to detected potential double definitions. */
6808 static int
6810 tree class_type;
6811 {
6817 {
6830 {
6832 {
6836 }
6837 else
6838 {
6839 seen_once++;
6840 parse_error_context
6845 }
6846 }
6847 }
6850 {
6851 /* Setup lineno so that it refers to the line of the import (in
6852 case we parse a class file and encounter errors */
6853 tree decl;
6859 /* If there is no DECL set for the class or if the class isn't
6860 loaded and not seen in source yet, the load */
6863 {
6866 }
6870 else
6871 /* 6.6.1: Inner classes are subject to member access rules. */
6873 }
6874 else
6876 }
6878 /* Add package NAME to the list of package encountered so far. To
6879 speed up class lookup in do_resolve_class, we make sure a
6880 particular package is added only once. */
6882 static void
6884 tree name;
6885 {
6889 {
6893 }
6896 {
6899 }
6900 }
6902 static tree
6905 {
6910 /* The trick is to determine when the package name stops and were
6911 the name of something contained in the package starts. Then we
6912 return a fully qualified name of what we want to get. */
6914 /* Do a quick search on well known package names */
6916 {
6920 }
6922 {
6925 }
6927 /* If we found something here, return */
6929 return type_name;
6933 /* Try to progressively construct a type name */
6937 {
6938 /* If we don't have what we're expecting, exit now. TYPE_NAME
6939 will be null and the error caught later. */
6941 break;
6944 {
6946 /* resolve_package should be used in a loop, hence we
6947 point at this one to naturally process the next one at
6948 the next iteration. */
6950 break;
6951 }
6952 }
6953 return type_name;
6954 }
6956 static tree
6960 {
6964 sub++;
6968 }
6970 /* Check accessibility of inner classes according to member access rules.
6971 DECL is the inner class, ENCLOSING_DECL is the class from which the
6972 access is being attempted. */
6974 static void
6977 {
6979 tree enclosing_decl_type;
6981 /* We don't issue an error message when CL is null. CL can be null
6982 as a result of processing a JDEP crafted by source_start_java_method
6983 for the purpose of patching its parm decl. But the error would
6984 have been already trapped when fixing the method's signature.
6985 DECL can also be NULL in case of earlier errors. */
6987 return;
6992 {
6993 /* Access is permitted only within the body of the top-level
6994 class in which DECL is declared. */
7001 return;
7003 }
7005 {
7006 tree decl_context;
7007 /* Access is permitted from within the same package... */
7009 return;
7011 /* ... or from within the body of a subtype of the context in which
7012 DECL is declared. */
7015 {
7017 {
7019 enclosing_decl_type))
7020 return;
7021 }
7022 else
7023 {
7024 /* Eww. The order of the arguments is different!! */
7027 return;
7028 }
7030 }
7032 }
7034 {
7035 /* Access is permitted only from within the same package as DECL. */
7037 return;
7039 }
7040 else
7041 /* Class is public. */
7042 return;
7047 }
7049 /* Accessibility check for top-level classes. If CLASS_NAME is in a foreign
7050 package, it must be PUBLIC. Return 0 if no access violations were found,
7051 1 otherwise. */
7053 static int
7055 tree class_name;
7056 tree cl;
7057 {
7058 tree type;
7067 {
7068 /* Access to a private class within the same package is
7069 allowed. */
7073 /* Both in the empty package. */
7076 /* Both in the same package. */
7079 parse_error_context
7080 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7084 }
7086 }
7088 /* Local variable declaration. */
7090 static void
7093 tree type;
7094 tree vlist;
7095 {
7101 /* Push a new block if statements were seen between the last time we
7102 pushed a block and now. Keep a count of blocks to close */
7104 {
7107 }
7110 {
7115 else
7116 {
7117 parse_error_context
7120 return;
7121 }
7122 }
7124 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7125 hold the TYPE value if a new incomplete has to be created (as
7126 opposed to being found already existing and reused). */
7129 /* If TYPE is fully resolved and we don't have a reference, make one */
7132 /* Go through all the declared variables */
7135 {
7141 /* Process NAME, as it may specify extra dimension(s) for it */
7144 /* Variable redefinition check */
7146 {
7149 continue;
7150 }
7152 /* Type adjustment. We may have just readjusted TYPE because
7153 the variable specified more dimensions. Make sure we have
7154 a reference if we can and don't have one already. */
7158 /* Never layout this decl. This will be done when its scope
7159 will be entered */
7165 /* If doing xreferencing, replace the line number with the WFL
7166 compound value */
7170 /* Don't try to use an INIT statement when an error was found */
7174 /* Add the initialization function to the current function's code */
7176 {
7177 /* Name might have been readjusted */
7182 init));
7183 }
7185 /* Setup dependency the type of the decl */
7187 {
7192 }
7193 }
7195 }
7197 /* Called during parsing. Build decls from argument list. */
7199 static void
7201 tree fndecl;
7202 {
7203 tree tem;
7204 tree parm_decl;
7208 return;
7212 /* New scope for the function */
7213 enter_block ();
7216 {
7220 /* If type is incomplete. Create an incomplete decl and ask for
7221 the decl to be patched later */
7223 {
7232 }
7233 else
7236 /* Remember if a local variable was declared final (via its
7237 TREE_LIST of type/name.) Set LOCAL_FINAL accordingly. */
7239 {
7242 }
7245 }
7251 }
7253 /* Called during parsing. Creates an artificial method declaration. */
7255 static tree
7257 tree class;
7260 {
7261 tree mdecl;
7263 java_parser_context_save_global ();
7269 java_parser_context_restore_global ();
7271 return mdecl;
7272 }
7274 /* Starts the body if an artifical method. */
7276 static void
7278 tree mdecl;
7279 {
7283 enter_block ();
7284 }
7286 static void
7288 tree mdecl;
7289 {
7290 /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7291 It has to be evaluated first. (if mdecl is current_function_decl,
7292 we have an undefined behavior if no temporary variable is used.) */
7295 exit_block ();
7296 }
7298 /* Terminate a function and expand its body. */
7300 static void
7301 source_end_java_method ()
7302 {
7306 return;
7308 java_parser_context_save_global ();
7311 /* Turn function bodies with only a NOP expr null, so they don't get
7312 generated at all and we won't get warnings when using the -W
7313 -Wall flags. */
7317 /* Generate function's code */
7319 && ! flag_emit_class_files
7323 /* pop out of its parameters */
7328 /* Generate rtl for function exit. */
7330 {
7334 /* Run the optimizers and output assembler code for this function. */
7336 }
7339 java_parser_context_restore_global ();
7340 }
7342 /* Record EXPR in the current function block. Complements compound
7343 expression second operand if necessary. */
7345 tree
7348 {
7350 return NULL_TREE;
7352 }
7354 static tree
7357 {
7361 return body;
7364 return body;
7368 return c;
7369 }
7371 /* Add STMT to EXISTING if possible, otherwise create a new
7372 COMPOUND_EXPR and add STMT to it. */
7374 static tree
7377 {
7380 else
7381 return stmt;
7382 }
7385 {
7388 tree current;
7391 {
7397 {
7400 }
7401 else
7402 break;
7403 }
7404 }
7406 void
7407 java_reorder_fields ()
7408 {
7411 tree current;
7413 /* Register STOP_REORDERING with the garbage collector. */
7415 {
7418 }
7421 {
7425 break;
7427 /* Reverse the fields, but leave the dummy field in front.
7428 Fields are already ordered for Object and Class */
7431 {
7432 /* If the dummy field is there, reverse the right fields and
7433 just layout the type for proper fields offset */
7435 {
7439 }
7440 /* We don't have a dummy field, we need to layout the class,
7441 after having reversed the fields */
7442 else
7443 {
7447 }
7448 }
7449 }
7450 /* There are cases were gclass_list will be empty. */
7453 }
7455 /* Layout the methods of all classes loaded in one way or another.
7456 Check methods of source parsed classes. Then reorder the
7457 fields and layout the classes or the type of all source parsed
7458 classes */
7460 void
7461 java_layout_classes ()
7462 {
7463 tree current;
7466 /* Layout the methods of all classes seen so far */
7467 java_layout_seen_class_methods ();
7468 java_parse_abort_on_error ();
7471 /* Then check the methods of all parsed classes */
7475 java_parse_abort_on_error ();
7478 {
7482 /* Error reported by the caller */
7484 return;
7485 }
7487 /* We might have reloaded classes durign the process of laying out
7488 classes for code generation. We must layout the methods of those
7489 late additions, as constructor checks might use them */
7490 java_layout_seen_class_methods ();
7491 java_parse_abort_on_error ();
7492 }
7494 /* Expand methods in the current set of classes rememebered for
7495 generation. */
7497 static void
7498 java_complete_expand_classes ()
7499 {
7500 tree current;
7507 }
7509 /* Expand the methods found in OUTER, starting first by OUTER's inner
7510 classes, if any. */
7512 static void
7514 tree outer;
7515 {
7516 tree inner_list;
7520 /* We need to go after all inner classes and start expanding them,
7521 starting with most nested ones. We have to do that because nested
7522 classes might add functions to outer classes */
7530 }
7532 /* Expand methods registered in CLASS_DECL. The general idea is that
7533 we expand regular methods first. This allows us get an estimate on
7534 how outer context local alias fields are really used so we can add
7535 to the constructor just enough code to initialize them properly (it
7536 also lets us generate finit$ correctly.) Then we expand the
7537 constructors and then <clinit>. */
7539 static void
7541 tree class_decl;
7542 {
7547 /* Find whether the class has final variables */
7550 {
7552 break;
7553 }
7555 /* Initialize a new constant pool */
7556 init_outgoing_cpool ();
7558 /* Pre-expand <clinit> to figure whether we really need it or
7559 not. If we do need it, we pre-expand the static fields so they're
7560 ready to be used somewhere else. <clinit> will be fully expanded
7561 after we processed the constructors. */
7565 /* Then generate finit$ (if we need to) because constructors will
7566 try to use it.*/
7570 /* Then generate instinit$ (if we need to) because constructors will
7571 try to use it. */
7575 /* Now do the constructors */
7577 {
7581 continue;
7584 /* Don't generate debug info on line zero when expanding a
7585 generated constructor. */
7589 /* Reset the final local variable assignment flags */
7595 /* Check for missed out final variable assignment */
7601 }
7603 /* First, do the ordinary methods. */
7605 {
7606 /* Ctors aren't part of this batch. */
7608 continue;
7610 /* Skip abstract or native methods -- but do handle native
7611 methods when generating JNI stubs. */
7613 {
7615 continue;
7616 }
7619 {
7622 }
7625 }
7627 /* If there is indeed a <clinit>, fully expand it now */
7629 {
7630 /* Reset the final local variable assignment flags */
7633 /* Prevent the use of `this' inside <clinit> */
7637 /* Check for missed out static final variable assignment */
7641 }
7643 /* We might have generated a class$ that we now want to expand */
7647 /* Now verify constructor circularity (stop after the first one we
7648 prove wrong.) */
7653 break;
7655 /* Final check on the initialization of final variables. */
7657 {
7659 /* If we have an interface, check for uninitialized fields. */
7662 }
7664 /* Save the constant pool. We'll need to restore it later. */
7666 }
7668 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7669 safely used in some other methods/constructors. */
7671 static tree
7673 tree class_type;
7674 {
7678 return NULL_TREE;
7680 /* Go through all static fields and pre expand them */
7686 /* Then build the <clinit> method */
7693 /* We process the list of assignment we produced as the result of
7694 the declaration of initialized static field and add them as
7695 statement to the <clinit> method. */
7698 {
7700 /* We build the assignment expression that will initialize the
7701 field to its value. There are strict rules on static
7702 initializers (8.5). FIXME */
7706 }
7710 /* Now we want to place <clinit> as the last method (because we need
7711 it at least for interface so that it doesn't interfere with the
7712 dispatch table based lookup. */
7714 {
7723 }
7725 return mdecl;
7726 }
7728 /* Analyzes a method body and look for something that isn't a
7729 MODIFY_EXPR with a constant value. */
7731 static int
7733 tree bbody;
7734 {
7737 {
7738 case BLOCK:
7740 break;
7742 case EXPR_WITH_FILE_LOCATION:
7744 break;
7746 case COMPOUND_EXPR:
7750 break;
7752 case MODIFY_EXPR:
7753 /* Return 0 if the operand is constant, 1 otherwise. */
7756 default:
7758 }
7760 }
7763 /* See whether we could get rid of <clinit>. Criteria are: all static
7764 final fields have constant initial values and the body of <clinit>
7765 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7767 static int
7769 tree mdecl;
7770 {
7778 /* If the body isn't empty, then we keep <clinit>. Note that if
7779 we're emitting classfiles, this isn't enough not to rule it
7780 out. */
7785 else
7795 {
7796 tree f_init;
7798 /* We're not interested in non static field */
7800 continue;
7802 /* Anything that isn't String or a basic type is ruled out -- or
7803 if we know how to deal with it (when doing things natively) we
7804 should generated an empty <clinit> so that SUID are computed
7805 correctly. */
7808 break;
7811 /* If we're emitting native code, we want static final fields to
7812 have constant initializers. If we don't meet these
7813 conditions, we keep <clinit> */
7814 if (!flag_emit_class_files
7816 break;
7817 /* If we're emitting bytecode, we want static fields to have
7818 constant initializers or no initializer. If we don't meet
7819 these conditions, we keep <clinit> */
7821 break;
7822 }
7824 /* Now we analyze the method body and look for something that
7825 isn't a MODIFY_EXPR */
7828 else
7834 /* Get rid of <clinit> in the class' list of methods */
7837 else
7841 {
7843 break;
7844 }
7847 }
7849 /* Install the argument from MDECL. Suitable to completion and
7850 expansion of mdecl's body. */
7852 static void
7854 tree mdecl;
7855 {
7863 {
7866 if (PROMOTE_PROTOTYPES
7876 }
7881 }
7884 /* Complete and expand a method. */
7886 static void
7888 tree mdecl;
7889 {
7893 /* Fix constructors before expanding them */
7897 /* Expand functions that have a body */
7899 return;
7914 /* Prepare the function for tree completion */
7917 /* Install the current this */
7921 /* Purge the `throws' list of unchecked exceptions. If we're doing
7922 xref, save a copy of the list and re-install it later. */
7927 /* Install exceptions thrown with `throws' */
7931 {
7934 /* Before we check initialization, attached all class initialization
7935 variable to the block_body */
7940 {
7943 /* Go through all the flags marking the initialization of
7944 static variables and see whether they're definitively
7945 assigned, in which case the type is remembered as
7946 definitively initialized in MDECL. */
7948 {
7952 /* Always register the context as properly initialized in
7953 MDECL. This used with caution helps removing extra
7954 initialization of self. */
7959 }
7960 }
7962 }
7966 /* If we saw a return but couldn't evaluate it properly, we'll have
7967 an error_mark_node here. */
7974 /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
7977 /* Pop the current level, with special measures if we found errors. */
7982 /* Pop the exceptions and sanity check */
7983 POP_EXCEPTIONS();
7985 abort ();
7987 /* Restore the copy of the list of exceptions if emitting xrefs. */
7990 }
7992 /* For with each class for which there's code to generate. */
7994 static void
7996 tree class;
7997 {
7998 tree decl;
8000 {
8002 continue;
8006 /* It's time to assign the variable flagging static class
8007 initialization based on which classes invoked static methods
8008 are definitely initializing. This should be flagged. */
8013 /* Prepare the function for RTL expansion */
8016 /* Expand function start, generate initialization flag
8017 assignment, and handle synchronized methods. */
8020 /* Expand the rest of the function body and terminate
8021 expansion. */
8022 source_end_java_method ();
8023 }
8024 }
8026 \f
8028 /* This section of the code deals with accessing enclosing context
8029 fields either directly by using the relevant access to this$<n> or
8030 by invoking an access method crafted for that purpose. */
8032 /* Build the necessary access from an inner class to an outer
8033 class. This routine could be optimized to cache previous result
8034 (decl, current_class and returned access). When an access method
8035 needs to be generated, it always takes the form of a read. It might
8036 be later turned into a write by calling outer_field_access_fix. */
8038 static tree
8041 {
8046 /* If the immediate enclosing context of the current class is the
8047 field decl's class or inherits from it; build the access as
8048 `this$<n>.<field>'. Note that we will break the `private' barrier
8049 if we're not emitting bytecodes. */
8052 {
8056 }
8057 /* Otherwise, generate access methods to outer this and access the
8058 field (either using an access method or by direct access.) */
8059 else
8060 {
8063 /* Now we chain the required number of calls to the access$0 to
8064 get a hold to the enclosing instance we need, and then we
8065 build the field access. */
8068 /* If the field is private and we're generating bytecode, then
8069 we generate an access method */
8071 {
8075 }
8076 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8077 Once again we break the `private' access rule from a foreign
8078 class. */
8079 else
8081 }
8083 }
8085 /* Return a non zero value if NODE describes an outer field inner
8086 access. */
8088 static int
8091 {
8097 /* If the inner class extends the declaration context of the field
8098 we're try to acces, then this isn't an outer field access */
8104 {
8109 {
8110 /* Before we give up, see whether the field is inherited from
8111 the enclosing context we're considering. */
8114 break;
8115 }
8116 }
8119 }
8121 /* Return a non zero value if NODE represents an outer field inner
8122 access that was been already expanded. As a side effect, it returns
8123 the name of the field being accessed and the argument passed to the
8124 access function, suitable for a regeneration of the access method
8125 call if necessary. */
8127 static int
8130 {
8136 /* Well, gcj generates slightly different tree nodes when compiling
8137 to native or bytecodes. It's the case for function calls. */
8139 if (flag_emit_class_files
8144 {
8149 {
8153 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8156 }
8157 }
8160 {
8165 }
8166 return identified;
8167 }
8169 /* Detect in NODE an outer field read access from an inner class and
8170 transform it into a write with RHS as an argument. This function is
8171 called from the java_complete_lhs when an assignment to a LHS can
8172 be identified. */
8174 static tree
8177 {
8181 {
8182 /* At any rate, check whether we're trying to assign a value to
8183 a final. */
8188 return error_mark_node;
8193 }
8194 return NULL_TREE;
8195 }
8197 /* Construct the expression that calls an access method:
8198 <type>.access$<n>(<arg1> [, <arg2>]);
8200 ARG2 can be NULL and will be omitted in that case. It will denote a
8201 read access. */
8203 static tree
8207 {
8220 }
8222 static tree
8223 build_new_access_id ()
8224 {
8230 }
8232 /* Create the static access functions for the outer field DECL. We define a
8233 read:
8234 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8235 return inst$.field;
8236 }
8237 and a write access:
8238 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8239 TREE_TYPE (<field>) value$) {
8240 return inst$.field = value$;
8241 }
8242 We should have a usage flags on the DECL so we can lazily turn the ones
8243 we're using for code generation. FIXME.
8244 */
8246 static tree
8248 tree decl;
8249 {
8257 /* Create the identifier and a function named after it. */
8260 /* The identifier is marked as bearing the name of a generated write
8261 access function for outer field accessed from inner classes. */
8264 /* Create the read access */
8274 /* Create the write access method. No write access for final variable */
8276 {
8288 }
8291 /* Return the access name */
8293 }
8295 /* Build an field access method NAME. */
8297 static tree
8300 {
8303 /* Create the method */
8308 /* Attach the method body. */
8315 return mdecl;
8316 }
8318 \f
8319 /* This section deals with building access function necessary for
8320 certain kinds of method invocation from inner classes. */
8322 static tree
8324 tree decl;
8325 {
8332 /* Test this abort with an access to a private field */
8334 abort ();
8336 /* Check the cache first */
8342 /* Obtain an access identifier and mark it */
8347 /* Create the arguments, as much as the original */
8350 {
8354 }
8357 /* Create the method */
8361 /* There is a potential bug here. We should be able to use
8362 fix_method_argument_names, but then arg names get mixed up and
8363 eventually a constructor will have its this$0 altered and the
8364 outer context won't be assignment properly. The test case is
8365 stub.java FIXME */
8368 /* Attach the method body. */
8372 /* The actual method invocation uses the same args. When invoking a
8373 static methods that way, we don't want to skip the first
8374 argument. */
8380 call_args);
8383 call_args);
8393 /* Back tag the access function so it know what it accesses */
8396 /* Tag the current method so it knows it has an access generated */
8398 }
8400 \f
8401 /* This section of the code deals with building expressions to access
8402 the enclosing instance of an inner class. The enclosing instance is
8403 kept in a generated field called this$<n>, with <n> being the
8404 inner class nesting level (starting from 0.) */
8406 /* Build an access to a given this$<n>, always chaining access call to
8407 others. Access methods to this$<n> are build on the fly if
8408 necessary. This CAN'T be used to solely access this$<n-1> from
8409 this$<n> (which alway yield to special cases and optimization, see
8410 for example build_outer_field_access). */
8412 static tree
8416 {
8420 {
8422 {
8425 }
8426 else
8427 {
8437 }
8439 /* if FROM isn't an inter class, that's fine, we've done
8440 enough. What we're looking for can be accessed from there. */
8443 break;
8445 }
8446 return access;
8447 }
8449 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8450 is returned if nothing needs to be generated. Otherwise, the method
8451 generated and a method decl is returned.
8453 NOTE: These generated methods should be declared in a class file
8454 attribute so that they can't be referred to directly. */
8456 static tree
8458 tree type;
8459 {
8461 tree saved_current_function_decl;
8463 /* If TYPE is a top-level class, no access method is required.
8464 If there already is such an access method, bail out. */
8466 return NULL_TREE;
8468 /* We generate the method. The method looks like:
8469 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8470 */
8491 return mdecl;
8492 }
8494 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8495 the first level of innerclassing. this$1 for the next one, etc...
8496 This function can be invoked with TYPE to NULL, available and then
8497 has to count the parser context. */
8499 static tree
8501 tree type;
8502 {
8508 tree decl;
8512 /* Register SAVED_THISN and SAVED_TYPE with the garbage collector. */
8514 {
8518 }
8521 {
8524 else
8525 {
8528 ;
8532 }
8533 }
8534 else
8538 return saved_thisn;
8543 return saved_thisn;
8544 }
8546 /* Return the assignement to the hidden enclosing context `this$<n>'
8547 by the second incoming parameter to the innerclass constructor. The
8548 form used is `this.this$<n> = this$<n>;'. */
8550 static tree
8551 build_thisn_assign ()
8552 {
8554 {
8561 }
8562 return NULL_TREE;
8563 }
8565 \f
8566 /* Building the synthetic `class$' used to implement the `.class' 1.1
8567 extension for non primitive types. This method looks like:
8569 static Class class$(String type) throws NoClassDefFoundError
8570 {
8571 try {return (java.lang.Class.forName (String));}
8572 catch (ClassNotFoundException e) {
8573 throw new NoClassDefFoundError(e.getMessage());}
8574 } */
8576 static tree
8578 tree class;
8579 {
8580 #define BWF(S) build_wfl_node (get_identifier ((S)))
8581 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8588 {
8593 }
8595 /* Build the arguments */
8600 /* Build the qualified name java.lang.Class.forName */
8606 /* Create the "class$" function */
8613 /* We start by building the try block. We need to build:
8614 return (java.lang.Class.forName (type)); */
8619 /* Now onto the catch block. We start by building the expression
8620 throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8625 /* Build new NoClassDefFoundError (_.getMessage) */
8626 throw_stmt = build_new_invocation
8630 /* Build the throw, (it's too early to use BUILD_THROW) */
8633 /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8646 return mdecl;
8647 }
8649 static tree
8651 tree type;
8652 {
8657 else
8664 }
8666 /* This section of the code deals with constructor. */
8668 /* Craft a body for default constructor. Patch existing constructor
8669 bodies with call to super() and field initialization statements if
8670 necessary. */
8672 static void
8674 tree mdecl;
8675 {
8682 return;
8686 {
8687 /* It is an error for the compiler to generate a default
8688 constructor if the superclass doesn't have a constructor that
8689 takes no argument, or the same args for an anonymous class */
8691 {
8696 parse_error_context
8701 }
8703 /* The constructor body must be crafted by hand. It's the
8704 constructor we defined when we realize we didn't have the
8705 CLASSNAME() constructor */
8708 /* Insert an assignment to the this$<n> hidden field, if
8709 necessary */
8713 /* We don't generate a super constructor invocation if we're
8714 compiling java.lang.Object. build_super_invocation takes care
8715 of that. */
8718 /* FIXME */
8723 }
8724 /* Search for an explicit constructor invocation */
8725 else
8726 {
8734 {
8735 case CALL_EXPR:
8740 break;
8741 case COMPOUND_EXPR:
8742 case EXPR_WITH_FILE_LOCATION:
8745 break;
8746 case BLOCK:
8749 break;
8750 default:
8753 }
8755 /* Generate the assignment to this$<n>, if necessary */
8759 /* The constructor is missing an invocation of super() */
8763 /* Explicit super() invokation should take place before the
8764 instance initializer blocks. */
8765 else
8766 {
8770 }
8772 /* Insert the instance initializer block right after. */
8776 /* Fix the constructor main block if we're adding extra stmts */
8778 {
8782 }
8783 }
8784 }
8786 /* Browse constructors in the super class, searching for a constructor
8787 that doesn't take any argument. Return 0 if one is found, 1
8788 otherwise. If the current class is an anonymous inner class, look
8789 for something that has the same signature. */
8791 static int
8793 tree mdecl;
8794 {
8797 tree sdecl;
8803 {
8804 tree mdecl_arg_type;
8808 {
8809 tree m_arg_type;
8818 if (!valid_method_invocation_conversion_p
8821 break;
8825 }
8826 }
8827 else
8828 {
8830 {
8836 }
8837 }
8839 }
8841 /* Generate code for all context remembered for code generation. */
8843 void
8844 java_expand_classes ()
8845 {
8849 java_parse_abort_on_error ();
8851 return;
8852 java_layout_classes ();
8853 java_parse_abort_on_error ();
8857 {
8862 java_parse_abort_on_error ();
8863 }
8866 /* Find anonymous classes and expand their constructor, now they
8867 have been fixed. */
8869 {
8870 tree current;
8873 {
8876 {
8877 tree d;
8879 {
8881 {
8886 }
8887 }
8888 }
8889 }
8890 }
8892 /* If we've found error at that stage, don't try to generate
8893 anything, unless we're emitting xrefs or checking the syntax only
8894 (but not using -fsyntax-only for the purpose of generating
8895 bytecode. */
8898 return;
8900 /* Now things are stable, go for generation of the class data. */
8902 {
8903 tree current;
8906 {
8914 {
8916 finish_class ();
8917 }
8918 }
8919 }
8920 }
8922 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
8923 a tree list node containing RIGHT. Fore coming RIGHTs will be
8924 chained to this hook. LOCATION contains the location of the
8925 separating `.' operator. */
8927 static tree
8931 {
8932 tree wfl;
8936 else
8937 {
8939 /* If wfl wasn't qualified, we build a first anchor */
8942 }
8944 /* And chain them */
8948 return wfl;
8949 }
8951 /* Simple merge of two name separated by a `.' */
8953 static tree
8956 {
8957 tree node;
8959 return NULL_TREE;
8962 return right;
8965 return left;
8975 return node;
8976 }
8978 /* Merge the two parts of a qualified name into LEFT. Set the
8979 location information of the resulting node to LOCATION, usually
8980 inherited from the location information of the `.' operator. */
8982 static tree
8986 {
8987 #ifdef USE_COMPONENT_REF
8990 return node;
8991 #else
8998 /* Left wasn't qualified and is now qualified */
9000 {
9004 }
9011 return left;
9012 #endif
9013 }
9015 /* Extract the last identifier component of the qualified in WFL. The
9016 last identifier is removed from the linked list */
9018 static tree
9020 tree wfl;
9021 {
9022 tree q;
9026 {
9028 /* Operating on a non qualified qualified WFL. */
9029 abort ();
9033 }
9034 }
9036 /* Resolve the expression name NAME. Return its decl. */
9038 static tree
9040 tree id;
9042 {
9044 tree decl;
9046 /* 6.5.5.1: Simple expression names */
9048 {
9049 /* 15.13.1: NAME can appear within the scope of a local variable
9050 declaration */
9052 return decl;
9054 /* 15.13.1: NAME can appear within a class declaration */
9055 else
9056 {
9059 {
9063 /* If we're accessing an outer scope local alias, make
9064 sure we change the name of the field we're going to
9065 build access to. */
9069 /* Instance variable (8.3.1.1) can't appear within
9070 static method, static initializer or initializer for
9071 a static variable. */
9073 {
9075 return error_mark_node;
9076 }
9077 /* Instance variables can't appear as an argument of
9078 an explicit constructor invocation */
9081 {
9082 parse_error_context
9083 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9084 return error_mark_node;
9085 }
9087 /* If we're processing an inner class and we're trying
9088 to access a field belonging to an outer class, build
9089 the access to the field */
9091 {
9093 {
9095 return error_mark_node;
9096 }
9100 return access;
9101 }
9103 /* Otherwise build what it takes to access the field */
9108 /* We may be asked to save the real field access node */
9111 /* And we return what we got */
9112 return access;
9113 }
9114 /* Fall down to error report on undefined variable */
9115 }
9116 }
9117 /* 6.5.5.2 Qualified Expression Names */
9118 else
9119 {
9123 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9124 /* 15.10.2: Accessing Superclass Members using super */
9126 }
9128 /* We've got an error here */
9131 "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9133 IDENTIFIER_POINTER (DECL_NAME
9135 else
9139 return error_mark_node;
9140 }
9142 static void
9145 {
9146 parse_error_context
9151 }
9153 /* 15.10.1 Field Acess Using a Primary and/or Expression Name.
9154 We return something suitable to generate the field access. We also
9155 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
9156 recipient's address can be null. */
9158 static tree
9160 tree qual_wfl;
9162 {
9164 tree field_ref;
9169 return error_mark_node;
9171 /* Resolve the LENGTH field of an array here */
9175 {
9179 /* In case we're dealing with a static array, we need to
9180 initialize its class before the array length can be fetched.
9181 It's also a good time to create a DECL_RTL for the field if
9182 none already exists, otherwise if the field was declared in a
9183 class found in an external file and hasn't been (and won't
9184 be) accessed for its value, none will be created. */
9186 {
9189 }
9190 }
9191 /* We might have been trying to resolve field.method(). In which
9192 case, the resolution is over and decl is the answer */
9196 {
9204 return error_mark_node;
9207 }
9208 else
9216 return field_ref;
9217 }
9219 /* If NODE is an access to f static field, strip out the class
9220 initialization part and return the field decl, otherwise, return
9221 NODE. */
9223 static tree
9225 tree node;
9226 {
9228 {
9231 {
9238 }
9240 return op1;
9241 }
9242 return node;
9243 }
9245 /* 6.5.5.2: Qualified Expression Names */
9247 static int
9249 tree wfl;
9251 {
9257 /* For certain for of inner class instantiation */
9259 #define RESTORE_THIS_AND_CURRENT_CLASS \
9265 {
9270 /* 15.10.1 Field Access Using a Primary */
9272 {
9273 case CALL_EXPR:
9274 case NEW_CLASS_EXPR:
9275 /* If the access to the function call is a non static field,
9276 build the code to access it. */
9278 {
9283 }
9285 /* And code for the function call */
9289 /* We might have to setup a new current class and a new this
9290 for the search of an inner class, relative to the type of
9291 a expression resolved as `decl'. The current values are
9292 saved and restored shortly after */
9295 if (decl
9297 || from_qualified_this))
9298 {
9299 /* If we still have `from_qualified_this', we have the form
9300 <T>.this.f() and we need to build <T>.this */
9302 {
9306 }
9310 }
9317 from_super,
9320 {
9321 RESTORE_THIS_AND_CURRENT_CLASS;
9323 }
9326 /* If we're creating an inner class instance, check for that
9327 an enclosing instance is in scope */
9330 {
9331 parse_error_context
9336 RESTORE_THIS_AND_CURRENT_CLASS;
9338 }
9340 /* In case we had to change then to resolve a inner class
9341 instantiation using a primary qualified by a `new' */
9342 RESTORE_THIS_AND_CURRENT_CLASS;
9344 /* EH check. No check on access$<n> functions */
9345 if (location
9346 && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9350 /* If the previous call was static and this one is too,
9351 build a compound expression to hold the two (because in
9352 that case, previous function calls aren't transported as
9353 forcoming function's argument. */
9355 {
9358 }
9359 else
9360 {
9363 }
9365 continue;
9367 case NEW_ARRAY_EXPR:
9368 case NEW_ANONYMOUS_ARRAY_EXPR:
9373 continue;
9375 case CONVERT_EXPR:
9381 continue;
9383 case CONDITIONAL_EXPR:
9384 case STRING_CST:
9385 case MODIFY_EXPR:
9390 continue;
9392 case ARRAY_REF:
9393 /* If the access to the function call is a non static field,
9394 build the code to access it. */
9396 {
9400 }
9401 /* And code for the array reference expression */
9406 continue;
9408 case PLUS_EXPR:
9415 break;
9417 case CLASS_LITERAL:
9422 break;
9424 default:
9425 /* Fix for -Wall Just go to the next statement. Don't
9426 continue */
9427 break;
9428 }
9430 /* If we fall here, we weren't processing a (static) function call. */
9433 /* It can be the keyword THIS */
9436 {
9438 {
9439 parse_error_context
9442 }
9445 {
9446 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9448 }
9449 /* We have to generate code for intermediate acess */
9451 {
9454 }
9455 /* We're trying to access the this from somewhere else. Make sure
9456 it's allowed before doing so. */
9457 else
9458 {
9460 {
9462 parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9467 }
9469 /* If there's nothing else after that, we need to
9470 produce something now, otherwise, the section of the
9471 code that needs to produce <T>.this will generate
9472 what is necessary. */
9474 {
9478 }
9479 }
9482 continue;
9483 }
9485 /* 15.10.2 Accessing Superclass Members using SUPER */
9488 {
9489 tree node;
9490 /* Check on the restricted use of SUPER */
9493 {
9494 parse_error_context
9497 }
9498 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9507 continue;
9508 }
9510 /* 15.13.1: Can't search for field name in packages, so we
9511 assume a variable/class name was meant. */
9513 {
9516 {
9517 tree list;
9519 /* We want to be absolutely sure that the class is laid
9520 out. We're going to search something inside it. */
9525 /* Fix them all the way down, if any are left. */
9527 {
9530 {
9534 }
9535 }
9536 }
9537 else
9538 {
9540 parse_error_context
9545 else
9546 parse_error_context
9550 }
9551 }
9553 /* We have a type name. It's been already resolved when the
9554 expression was qualified. */
9556 {
9560 /* Sneak preview. If next we see a `new', we're facing a
9561 qualification with resulted in a type being selected
9562 instead of a field. Report the error */
9565 {
9569 }
9572 {
9573 parse_error_context
9580 }
9585 }
9586 /* We resolve and expression name */
9587 else
9588 {
9591 /* If there exists an early resolution, use it. That occurs
9592 only once and we know that there are more things to
9593 come. Don't do that when processing something after SUPER
9594 (we need more thing to be put in place below */
9596 {
9599 {
9601 {
9604 else
9605 {
9607 current_class);
9609 }
9612 }
9613 else
9614 {
9618 }
9619 }
9620 }
9622 /* We have to search for a field, knowing the type of its
9623 container. The flag FROM_TYPE indicates that we resolved
9624 the last member of the expression as a type name, which
9625 means that for the resolution of this field, we'll look
9626 for other errors than if it was resolved as a member of
9627 an other field. */
9628 else
9629 {
9634 {
9635 parse_error_context
9641 }
9646 /* Maybe what we're trying to access to is an inner
9647 class, only if decl is a TYPE_DECL. */
9649 {
9655 {
9660 continue;
9661 }
9662 }
9665 {
9666 parse_error_context
9671 }
9675 /* Layout the type of field_decl, since we may need
9676 it. Don't do primitive types or loaded classes. The
9677 situation of non primitive arrays may not handled
9678 properly here. FIXME */
9681 else
9688 /* Check on accessibility here */
9691 {
9692 parse_error_context
9695 java_accstring_lookup
9699 IDENTIFIER_POINTER
9702 }
9705 /* There are things to check when fields are accessed
9706 from type. There are no restrictions on a static
9707 declaration of the field when it is accessed from an
9708 interface */
9712 && !is_static
9713 && (current_function_decl
9715 {
9718 }
9721 /* It's an access from a type but it isn't static, we
9722 make it relative to `this'. */
9726 /* If we need to generate something to get a proper
9727 handle on what this field is accessed from, do it
9728 now. */
9730 {
9734 }
9736 /* We want to keep the location were found it, and the type
9737 we found. */
9741 /* Generate the correct expression for field access from
9742 qualified this */
9744 {
9747 }
9749 /* This is the decl found and eventually the next one to
9750 search from */
9752 }
9756 /* Sneak preview. If decl is qualified by a `new', report
9757 the error here to be accurate on the peculiar construct */
9761 {
9765 }
9766 }
9767 /* `q' might have changed due to a after package resolution
9768 re-qualification */
9770 break;
9771 }
9774 }
9776 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9777 can't be accessed from REFERENCE (a record type). If MEMBER
9778 features a protected access, we then use WHERE which, if non null,
9779 holds the type of MEMBER's access that is checked against
9780 6.6.2.1. This function should be used when decl is a field or a
9781 method. */
9783 static int
9786 tree where;
9788 {
9791 /* Inner classes are processed by check_inner_class_access */
9795 /* Access always granted for members declared public */
9799 /* Check access on protected members */
9801 {
9802 /* Access granted if it occurs from within the package
9803 containing the class in which the protected member is
9804 declared */
9808 /* If accessed with the form `super.member', then access is granted */
9812 /* If where is active, access was made through a
9813 qualifier. Access is granted if the type of the qualifier is
9814 or is a sublass of the type the access made from (6.6.2.1.) */
9818 /* Otherwise, access is granted if occuring from the class where
9819 member is declared or a subclass of it. Find the right
9820 context to perform the check */
9822 {
9824 {
9828 }
9829 }
9833 }
9835 /* Check access on private members. Access is granted only if it
9836 occurs from within the class in which it is declared -- that does
9837 it for innerclasses too. */
9839 {
9845 }
9847 /* Default access are permitted only when occuring within the
9848 package in which the type (REFERENCE) is declared. In other words,
9849 REFERENCE is defined in the current package */
9853 /* Otherwise, access is granted */
9855 }
9857 /* Test deprecated decl access. */
9858 static void
9861 {
9863 /* Complain if the field is deprecated and the file it was defined
9864 in isn't compiled at the same time the file which contains its
9865 use is */
9868 {
9871 {
9872 case FUNCTION_DECL:
9874 break;
9875 case FIELD_DECL:
9877 break;
9878 case TYPE_DECL:
9880 break;
9881 default:
9882 abort ();
9883 }
9884 parse_warning_context
9888 }
9889 }
9891 /* Returns 1 if class was declared in the current package, 0 otherwise */
9893 static int
9895 tree class;
9896 {
9899 tree left;
9906 /* If the current package is empty and the name of CLASS is
9907 qualified, class isn't in the current package. If there is a
9908 current package and the name of the CLASS is not qualified, class
9909 isn't in the current package */
9913 /* If there is not package and the name of CLASS isn't qualified,
9914 they belong to the same unnamed package */
9918 /* Compare the left part of the name of CLASS with the package name */
9921 {
9923 /* Register CACHE with the garbage collector. */
9925 {
9928 }
9932 }
9934 }
9936 /* This function may generate code to access DECL from WHERE. This is
9937 done only if certain conditions meet. */
9939 static tree
9942 {
9948 return decl;
9949 }
9951 /* Build a method invocation, by patching PATCH. If non NULL
9952 and according to the situation, PRIMARY and WHERE may be
9953 used. IS_STATIC is set to 1 if the invoked function is static. */
9955 static tree
9962 {
9966 tree list;
9972 /* Should be overriden if everything goes well. Otherwise, if
9973 something fails, it should keep this value. It stop the
9974 evaluation of a bogus assignment. See java_complete_tree,
9975 MODIFY_EXPR: for the reasons why we sometimes want to keep on
9976 evaluating an assignment */
9979 /* Since lookup functions are messing with line numbers, save the
9980 context now. */
9981 java_parser_context_save_global ();
9983 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
9985 /* Resolution of qualified name, excluding constructors */
9987 {
9989 /* Extract the last IDENTIFIER of the qualified
9990 expression. This is a wfl and we will use it's location
9991 data during error report. */
9995 /* Given the context, IDENTIFIER is syntactically qualified
9996 as a MethodName. We need to qualify what's before */
10001 PATCH_METHOD_RETURN_ERROR ();
10007 {
10008 parse_error_context
10012 PATCH_METHOD_RETURN_ERROR ();
10013 }
10018 /* We're resolving a call from a type */
10020 {
10022 {
10023 parse_error_context
10028 PATCH_METHOD_RETURN_ERROR ();
10029 }
10031 {
10033 parse_error_context
10039 PATCH_METHOD_RETURN_ERROR ();
10040 }
10041 }
10042 else
10048 /* IDENTIFIER_WFL will be used to report any problem further */
10050 }
10051 /* Resolution of simple names, names generated after a primary: or
10052 constructors */
10053 else
10054 {
10058 /* We search constructor in their target class */
10060 {
10064 this_identifier_node)
10067 super_identifier_node)
10068 {
10071 class_to_search =
10073 else
10074 {
10076 PATCH_METHOD_RETURN_ERROR ();
10077 }
10078 }
10080 /* Class to search is NULL if we're searching the current one */
10082 {
10086 {
10087 parse_error_context
10090 PATCH_METHOD_RETURN_ERROR ();
10091 }
10093 /* Can't instantiate an abstract class, but we can
10094 invoke it's constructor. It's use within the `new'
10095 context is denied here. */
10098 {
10099 parse_error_context
10102 PATCH_METHOD_RETURN_ERROR ();
10103 }
10106 }
10107 else
10110 }
10111 /* This is a regular search in the local class, unless an
10112 alternate class is specified. */
10113 else
10114 {
10119 else
10120 {
10123 for (;;)
10124 {
10126 break;
10128 {
10132 PATCH_METHOD_RETURN_ERROR ();
10133 }
10134 class_to_search
10136 }
10137 }
10139 }
10141 /* NAME is a simple identifier or comes from a primary. Search
10142 in the class whose declaration contain the method being
10143 invoked. */
10147 /* Don't continue if no method were found, as the next statement
10148 can't be executed then. */
10150 PATCH_METHOD_RETURN_ERROR ();
10156 /* Check for static reference if non static methods */
10159 PATCH_METHOD_RETURN_ERROR ();
10161 /* Check for inner classes creation from illegal contexts */
10165 {
10166 parse_error_context
10171 PATCH_METHOD_RETURN_ERROR ();
10172 }
10174 /* Non static methods are called with the current object extra
10175 argument. If patch a `new TYPE()', the argument is the value
10176 returned by the object allocator. If method is resolved as a
10177 primary, use the primary otherwise use the current THIS. */
10180 {
10183 /* If we're using an access method, things are different.
10184 There are two familly of cases:
10186 1) We're not generating bytecodes:
10188 - LIST is non static. It's invocation is transformed from
10189 x(a1,...,an) into this$<n>.x(a1,....an).
10190 - LIST is static. It's invocation is transformed from
10191 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10193 2) We're generating bytecodes:
10195 - LIST is non static. It's invocation is transformed from
10196 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10197 - LIST is static. It's invocation is transformed from
10198 x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10200 Of course, this$<n> can be abitrary complex, ranging from
10201 this$0 (the immediate outer context) to
10202 access$0(access$0(...(this$0))).
10204 maybe_use_access_method returns a non zero value if the
10205 this_arg has to be moved into the (then generated) stub
10206 argument list. In the meantime, the selected function
10207 might have be replaced by a generated stub. */
10210 {
10213 }
10214 }
10215 }
10217 /* Merge point of all resolution schemes. If we have nothing, this
10218 is an error, already signaled */
10220 PATCH_METHOD_RETURN_ERROR ();
10222 /* Check accessibility, position the is_static flag, build and
10223 return the call */
10227 /* Calls to clone() on array types are permitted as a special-case. */
10229 {
10239 /* FIXME: WFL yields the wrong message here but I don't know
10240 what else to use. */
10244 PATCH_METHOD_RETURN_ERROR ();
10245 }
10248 /* If invoking a innerclass constructor, there are hidden parameters
10249 to pass */
10252 {
10253 /* And make sure we add the accessed local variables to be saved
10254 in field aliases. */
10255 args = build_alias_initializer_parameter_list
10258 /* Secretly pass the current_this/primary as a second argument */
10260 {
10261 tree extra_arg;
10262 tree this_type = (current_this ?
10264 /* Method's (list) enclosing context */
10266 /* If we have a primary, use it. */
10269 /* The current `this' is an inner class but isn't a direct
10270 enclosing context for the inner class we're trying to
10271 create. Build an access to the proper enclosing context
10272 and use it. */
10275 {
10280 }
10281 /* Otherwise, just use the current `this' as an enclosing
10282 context. */
10283 else
10286 }
10287 else
10289 }
10291 /* This handles the situation where a constructor invocation needs
10292 to have an enclosing context passed as a second parameter (the
10293 constructor is one of an inner class. We extract it from the
10294 current function. */
10295 if ((is_super_init ||
10298 {
10300 tree extra_arg;
10303 {
10306 }
10307 else
10308 {
10310 extra_arg =
10313 }
10315 }
10321 /* In the context of an explicit constructor invocation, we can't
10322 invoke any method relying on `this'. Exceptions are: we're
10323 invoking a static function, primary exists and is not the current
10324 this, we're creating a new object. */
10326 && !is_static_flag
10329 {
10330 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10331 PATCH_METHOD_RETURN_ERROR ();
10332 }
10333 java_parser_context_restore_global ();
10336 /* Sometimes, we want the decl of the selected method. Such as for
10337 EH checking */
10342 /* Now is a good time to insert the call to finit$ */
10344 {
10347 /* Prepare to pass hidden parameters to finit$, if any. */
10348 finit_parms = build_alias_initializer_parameter_list
10351 finit_call =
10353 finit_parms);
10355 /* Generate the code used to initialize fields declared with an
10356 initialization statement and build a compound statement along
10357 with the super constructor invocation. */
10361 }
10362 return patch;
10363 }
10365 /* Check that we're not trying to do a static reference to a method in
10366 non static method. Return 1 if it's the case, 0 otherwise. */
10368 static int
10371 {
10374 {
10376 parse_error_context
10382 }
10384 }
10386 /* Fix the invocation of *MDECL if necessary in the case of a
10387 invocation from an inner class. *THIS_ARG might be modified
10388 appropriately and an alternative access to *MDECL might be
10389 returned. */
10391 static int
10395 {
10396 tree ctx;
10401 if (is_super_init
10408 /* If we're calling a method found in an enclosing class, generate
10409 what it takes to retrieve the right this. Don't do that if we're
10410 invoking a static method. Note that if MD's type is unrelated to
10411 CURRENT_CLASS, then the current this can be used. */
10414 {
10417 {
10420 }
10421 else
10422 {
10425 {
10428 {
10430 break;
10431 }
10434 }
10435 }
10437 }
10439 /* We might have to use an access method to get to MD. We can
10440 break the method access rule as far as we're not generating
10441 bytecode */
10443 {
10446 }
10451 /* Returnin a non zero value indicates we were doing a non static
10452 method invokation that is now a static invocation. It will have
10453 callee displace `this' to insert it in the regular argument
10454 list. */
10456 }
10458 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10459 mode. */
10461 static tree
10464 {
10469 /* Last step for args: convert build-in types. If we're dealing with
10470 a new TYPE() type call, the first argument to the constructor
10471 isn't found in the incoming argument list, but delivered by
10472 `new' */
10482 /* Resolve unresolved returned type isses */
10489 else
10490 {
10493 {
10494 case INVOKE_VIRTUAL:
10497 break;
10499 case INVOKE_NONVIRTUAL:
10500 /* If the object for the method call is null, we throw an
10501 exception. We don't do this if the object is the current
10502 method's `this'. In other cases we just rely on an
10503 optimization pass to eliminate redundant checks. */
10505 {
10506 /* We use a save_expr here to make sure we only evaluate
10507 the new `self' expression once. */
10511 }
10512 /* Fall through. */
10514 case INVOKE_SUPER:
10515 case INVOKE_STATIC:
10519 break;
10521 case INVOKE_INTERFACE:
10524 break;
10526 default:
10527 abort ();
10528 }
10530 /* Ensure self_type is initialized, (invokestatic). FIXME */
10532 }
10539 /* We're processing a `new TYPE ()' form. New is called and its
10540 returned value is the first argument to the constructor. We build
10541 a COMPOUND_EXPR and use saved expression so that the overall NEW
10542 expression value is a pointer to a newly created and initialized
10543 class. */
10545 {
10549 {
10551 return patch;
10552 }
10561 NULL_TREE);
10568 }
10570 /* If CHECK is set, then we are building a check to see if the object
10571 is NULL. */
10573 {
10576 }
10578 /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10579 put it as the first expression of a COMPOUND_EXPR. The second
10580 expression being an empty statement to be later patched if
10581 necessary. We remember a TREE_LIST (the PURPOSE is the method,
10582 the VALUE is the compound) in a hashtable and return a
10583 COMPOUND_EXPR built so that the result of the evaluation of the
10584 original PATCH node is returned. */
10587 {
10588 tree list;
10600 }
10602 return patch;
10603 }
10605 static int
10607 tree method;
10609 {
10613 return INVOKE_SUPER;
10616 return INVOKE_STATIC;
10618 /* We have to look for a constructor before we handle nonvirtual
10619 calls; otherwise the constructor will look nonvirtual. */
10621 return INVOKE_STATIC;
10624 return INVOKE_NONVIRTUAL;
10627 return INVOKE_NONVIRTUAL;
10630 return INVOKE_INTERFACE;
10632 return INVOKE_VIRTUAL;
10633 }
10635 /* Retrieve a refined list of matching methods. It covers the step
10636 15.11.2 (Compile-Time Step 2) */
10638 static tree
10641 tree cl;
10643 {
10649 /* Fix the arguments */
10651 {
10653 /* Non primitive type may have to be resolved */
10656 /* And promoted */
10660 }
10662 /* Presto. If we're dealing with an anonymous class and a
10663 constructor call, generate the right constructor now, since we
10664 know the arguments' types. */
10669 /* Find all candidates and then refine the list, searching for the
10670 most specific method. */
10676 /* Issue an error. List candidates if any. Candidates are listed
10677 only if accessible (non accessible methods may end-up here for
10678 the sake of a better error report). */
10681 {
10682 tree current;
10685 {
10689 continue;
10690 sprintf
10696 }
10699 }
10700 /* Issue the error message */
10711 return NULL_TREE;
10712 }
10714 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10715 when we're looking for a constructor. */
10717 static tree
10721 {
10726 /* Check the hash table to determine if this class has been searched
10727 already. */
10729 {
10732 return NULL;
10733 }
10734 else
10735 {
10737 java_hash_compare_tree_node);
10739 }
10741 search_not_done++;
10746 {
10749 }
10751 /* Search interfaces */
10754 {
10761 {
10763 tree rlist;
10766 arglist);
10768 }
10769 }
10770 /* Search classes */
10771 else
10772 {
10776 /* When looking finit$, class$ or instinit$, we turn LC to 1 so
10777 that we only search in class. Note that we should have found
10778 something at this point. */
10780 {
10783 abort ();
10784 }
10786 /* We must search all interfaces of this class */
10788 {
10792 {
10795 {
10796 tree rlist
10800 }
10801 }
10802 }
10804 /* Search superclass */
10806 {
10807 tree rlist;
10812 }
10813 }
10815 search_not_done--;
10817 /* We're done. Reset the searched classes list and finally search
10818 java.lang.Object if it wasn't searched already. */
10820 {
10821 if (!lc
10826 {
10830 }
10833 }
10835 /* Either return the list obtained or all selected (but
10836 inaccessible) methods for better error report. */
10838 }
10840 /* Effectively search for the appropriate method in method */
10842 static void
10847 {
10849 {
10850 /* When dealing with constructor, stop here, otherwise search
10851 other classes */
10853 continue;
10856 continue;
10859 {
10860 /* Retain accessible methods only */
10864 else
10865 /* Also retain all selected method here */
10867 }
10868 }
10869 }
10871 /* 15.11.2.2 Choose the Most Specific Method */
10873 static tree
10875 tree list;
10876 {
10881 {
10882 tree method;
10886 {
10888 /* Don't test a method against itself */
10890 continue;
10895 /* Compare arguments and location where methods where declared */
10897 {
10898 if (valid_method_invocation_conversion_p
10903 {
10907 }
10908 }
10909 }
10910 }
10912 /* Review the list and select the maximally specific methods */
10916 {
10919 candidates++;
10920 }
10922 /* If we have several and they're all abstract, just pick the
10923 closest one. */
10925 {
10928 }
10930 /* We have several (we couldn't find a most specific), all but one
10931 are abstract, we pick the only non abstract one. */
10933 {
10936 {
10939 }
10940 }
10942 /* If we can't find one, lower expectations and try to gather multiple
10943 maximally specific methods */
10945 {
10947 {
10950 }
10951 }
10953 return new_list;
10954 }
10956 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
10957 converted by method invocation conversion (5.3) to the type of the
10958 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
10959 to change less often than M1. */
10961 static int
10964 {
10971 /* Register M2_ARG_VALUE and M2_ARG_CACHE with the garbage
10972 collector. */
10974 {
10978 }
10984 else
10985 {
10986 /* M2_OR_ARGLIST can be a function DECL or a raw list of
10987 argument types */
10989 {
10993 }
10994 else
10999 }
11002 {
11006 break;
11009 }
11011 }
11013 /* Qualification routines */
11015 static void
11017 tree id;
11018 {
11020 saved_current_class;
11024 /* We first qualify the first element, then derive qualification of
11025 others based on the first one. If the first element is qualified
11026 by a resolution (field or type), this resolution is stored in the
11027 QUAL_RESOLUTION of the qual element being examined. We need to
11028 save the current_class since the use of SUPER might change the
11029 its value. */
11032 do {
11034 /* Simple qualified expression feature a qual_wfl that is a
11035 WFL. Expression derived from a primary feature more complicated
11036 things like a CALL_EXPR. Expression from primary need to be
11037 worked out to extract the part on which the qualification will
11038 take place. */
11041 {
11042 case CALL_EXPR:
11045 {
11048 }
11049 break;
11050 case NEW_ARRAY_EXPR:
11051 case NEW_ANONYMOUS_ARRAY_EXPR:
11054 continue;
11055 case CONVERT_EXPR:
11056 break;
11057 case NEW_CLASS_EXPR:
11059 break;
11060 case ARRAY_REF:
11063 break;
11064 case STRING_CST:
11067 break;
11068 case CLASS_LITERAL:
11071 break;
11072 default:
11073 /* Fix for -Wall. Just break doing nothing */
11074 break;
11075 }
11081 /* Pos evaluation: non WFL leading expression nodes */
11102 {
11106 }
11107 else
11108 {
11111 {
11114 }
11115 }
11117 /* If we have a THIS (from a primary), we set the context accordingly */
11119 {
11120 /* This isn't really elegant. One more added irregularity
11121 before I start using COMPONENT_REF (hopefully very soon.) */
11124 EXPR_WITH_FILE_LOCATION
11126 this_identifier_node)
11127 {
11130 }
11140 }
11141 /* If we have a SUPER, we set the context accordingly */
11143 {
11145 /* Check that there is such a thing as a super class. If not,
11146 return. The error will be caught later on, during the
11147 resolution */
11149 {
11151 return;
11152 }
11154 /* Do one more interation to set things up */
11156 }
11159 /* If name appears within the scope of a local variable declaration
11160 or parameter declaration, then it is an expression name. We don't
11161 carry this test out if we're in the context of the use of SUPER
11162 or THIS */
11166 {
11169 }
11171 /* If within the class/interface NAME was found to be used there
11172 exists a (possibly inherited) field named NAME, then this is an
11173 expression name. If we saw a NEW_ARRAY_EXPR before and want to
11174 address length, it is OK. */
11177 {
11180 }
11182 /* We reclassify NAME as yielding to a type name resolution if:
11183 - NAME is a class/interface declared within the compilation
11184 unit containing NAME,
11185 - NAME is imported via a single-type-import declaration,
11186 - NAME is declared in an another compilation unit of the package
11187 of the compilation unit containing NAME,
11188 - NAME is declared by exactly on type-import-on-demand declaration
11189 of the compilation unit containing NAME.
11190 - NAME is actually a STRING_CST.
11191 This can't happen if the expression was qualified by `this.' */
11196 {
11199 }
11201 /* Method call, array references and cast are expression name */
11208 /* Check here that NAME isn't declared by more than one
11209 type-import-on-demand declaration of the compilation unit
11210 containing NAME. FIXME */
11212 /* Otherwise, NAME is reclassified as a package name */
11213 else
11216 /* Propagate the qualification accross other components of the
11217 qualified name */
11220 {
11223 else
11225 }
11227 /* Store the global qualification for the ambiguous part of ID back
11228 into ID fields */
11236 /* Restore the current class */
11238 }
11240 static int
11243 {
11250 /* Breakdown NAME into REMAINDER . IDENTIFIER */
11253 p--;
11255 /* We didn't find a '.'. Return an error */
11265 }
11267 /* Return TRUE if two classes are from the same package. */
11269 static int
11272 {
11273 tree tmp;
11274 tree pkg1;
11275 tree pkg2;
11283 /* One in empty package. */
11287 /* Both in empty package. */
11294 }
11296 /* Patch tree nodes in a function body. When a BLOCK is found, push
11297 local variable decls if present.
11298 Same as java_complete_lhs, but does resolve static finals to values. */
11300 static tree
11302 tree node;
11303 {
11308 {
11314 {
11315 /* fold_constant_for_init sometimes widen the original type
11316 of the constant (i.e. byte to int.) It's not desirable,
11317 especially if NODE is a function argument. */
11321 else
11322 return value;
11323 }
11324 else
11326 }
11327 return node;
11328 }
11330 static tree
11332 tree node;
11333 {
11335 {
11340 return node;
11341 }
11343 }
11345 /* Patch tree nodes in a function body. When a BLOCK is found, push
11346 local variable decls if present.
11347 Same as java_complete_tree, but does not resolve static finals to values. */
11349 static tree
11351 tree node;
11352 {
11356 /* CONVERT_EXPR always has its type set, even though it needs to be
11357 worked out. */
11359 return node;
11361 /* The switch block implements cases processing container nodes
11362 first. Contained nodes are always written back. Leaves come
11363 next and return a value. */
11365 {
11366 case BLOCK:
11368 /* 1- Block section.
11369 Set the local values on decl names so we can identify them
11370 faster when they're referenced. At that stage, identifiers
11371 are legal so we don't check for declaration errors. */
11373 {
11376 }
11379 else
11380 {
11385 {
11386 /* Re-order from (((A; B); C); ...; Z) to
11387 (A; (B; (C ; (...; Z)))).
11388 This makes it easier to scan the statements left-to-right
11389 without using recursion (which might overflow the stack
11390 if the block has many statements. */
11391 for (;;)
11392 {
11395 break;
11399 }
11401 }
11403 /* Now do the actual complete, without deep recursion for
11404 long blocks. */
11408 {
11413 {
11414 /* Optimization; makes it easier to detect empty bodies.
11415 Most useful for <clinit> with all-constant initializer. */
11417 continue;
11418 }
11420 error_seen++;
11422 {
11424 for (;;)
11425 {
11430 else
11431 break;
11432 }
11436 }
11438 }
11442 return error_mark_node;
11444 }
11445 /* Turn local bindings to null */
11450 break;
11452 /* 2- They are expressions but ultimately deal with statements */
11454 case THROW_EXPR:
11457 /* 14.19 A throw statement cannot complete normally. */
11461 case SYNCHRONIZED_EXPR:
11465 case TRY_EXPR:
11468 case TRY_FINALLY_EXPR:
11479 return node;
11481 case CLEANUP_POINT_EXPR:
11486 return node;
11488 case WITH_CLEANUP_EXPR:
11494 return node;
11496 case LABELED_BLOCK_EXPR:
11501 POP_LABELED_BLOCK ();
11504 {
11507 }
11510 return node;
11512 case EXIT_BLOCK_EXPR:
11513 /* We don't complete operand 1, because it's the return value of
11514 the EXIT_BLOCK_EXPR which doesn't exist it Java */
11517 case CASE_EXPR:
11520 return cn;
11522 /* First, the case expression must be constant. Values of final
11523 fields are accepted. */
11529 {
11532 }
11535 {
11538 return error_mark_node;
11539 }
11543 /* It must be assignable to the type of the switch expression. */
11546 {
11548 parse_error_context
11552 return error_mark_node;
11553 }
11559 /* Multiple instance of a case label bearing the same
11560 value is checked during code generation. The case
11561 expression is allright so far. */
11568 break;
11570 case DEFAULT_EXPR:
11572 /* Only one default label is allowed per switch statement */
11574 {
11578 return error_mark_node;
11579 }
11580 else
11585 break;
11587 case SWITCH_EXPR:
11588 case LOOP_EXPR:
11590 /* Check whether the loop was enclosed in a labeled
11591 statement. If not, create one, insert the loop in it and
11592 return the node */
11595 /* Anyways, walk the body of the loop */
11598 /* Switch statement: walk the switch expression and the cases */
11599 else
11604 else
11605 {
11607 /* If we returned something different, that's because we
11608 inserted a label. Pop the label too. */
11610 {
11613 POP_LABELED_BLOCK ();
11614 }
11615 }
11616 POP_LOOP ();
11617 return nn;
11619 case EXIT_EXPR:
11623 case COND_EXPR:
11624 /* Condition */
11627 return error_mark_node;
11628 /* then-else branches */
11631 return error_mark_node;
11634 return error_mark_node;
11636 break;
11638 case CONDITIONAL_EXPR:
11639 /* Condition */
11648 /* 3- Expression section */
11649 case COMPOUND_EXPR:
11655 else
11656 {
11658 {
11659 /* An unreachable condition in a do-while statement
11660 is *not* (technically) an unreachable statement. */
11665 {
11668 }
11669 }
11672 return error_mark_node;
11675 }
11677 break;
11679 case RETURN_EXPR:
11680 /* CAN_COMPLETE_NORMALLY (node) = 0; */
11683 case EXPR_WITH_FILE_LOCATION:
11686 {
11690 return node;
11691 /* Keep line number information somewhere were it doesn't
11692 disrupt the completion process. */
11694 {
11697 }
11699 }
11700 else
11701 {
11702 tree body;
11711 {
11712 /* Makes it easier to constant fold, detect empty bodies. */
11713 return body;
11714 }
11716 {
11717 /* Its important for the evaluation of assignment that
11718 this mark on the TREE_TYPE is propagated. */
11720 return error_mark_node;
11721 }
11722 else
11725 }
11726 break;
11728 case NEW_ARRAY_EXPR:
11729 /* Patch all the dimensions */
11732 {
11737 {
11739 continue;
11740 }
11741 else
11742 {
11744 /* Setup the location of the current dimension, for
11745 later error report. */
11749 }
11750 }
11751 /* They complete the array creation expression, if no errors
11752 were found. */
11754 return (flag ? error_mark_node
11757 case NEW_ANONYMOUS_ARRAY_EXPR:
11758 /* Create the array type if necessary. */
11760 {
11763 return error_mark_node;
11767 }
11771 return error_mark_node;
11773 return node;
11775 case NEW_CLASS_EXPR:
11776 case CALL_EXPR:
11777 /* Complete function's argument(s) first */
11779 return error_mark_node;
11780 else
11781 {
11785 super_identifier_node);
11790 return error_mark_node;
11793 /* If we call this(...), register signature and positions */
11800 }
11802 case MODIFY_EXPR:
11803 /* Save potential wfls */
11810 {
11811 tree value;
11816 {
11820 return empty_stmt_node;
11821 }
11826 }
11830 return error_mark_node;
11834 {
11835 /* This might break when accessing outer field from inner
11836 class. TESTME, FIXME */
11839 /* Hand stabilize the lhs on both places */
11844 /* 15.25.2.a: Left hand is not an array access. FIXME */
11845 /* Now complete the RHS. We write it back later on. */
11851 /* The last part of the rewrite for E1 op= E2 is to have
11852 E1 = (T)(E1 op E2), with T being the type of E1. */
11856 /* If the assignment is compound and has reference type,
11857 then ensure the LHS has type String and nothing else. */
11864 /* 15.25.2.b: Left hand is an array access. FIXME */
11865 }
11867 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11868 function to complete this RHS. Note that a NEW_ARRAY_INIT
11869 might have been already fully expanded if created as a result
11870 of processing an anonymous array initializer. We avoid doing
11871 the operation twice by testing whether the node already bears
11872 a type. */
11876 /* Otherwise we simply complete the RHS */
11877 else
11881 return error_mark_node;
11883 /* Write back the RHS as we evaluated it. */
11886 /* In case we're handling = with a String as a RHS, we need to
11887 produce a String out of the RHS (it might still be a
11888 STRING_CST or a StringBuffer at this stage */
11894 {
11895 /* We return error_mark_node if outer_field_access_fix
11896 detects we write into a final. */
11898 return error_mark_node;
11900 }
11901 else
11902 {
11904 /* Reorganize the tree if necessary. */
11908 }
11911 return node;
11913 case MULT_EXPR:
11914 case PLUS_EXPR:
11915 case MINUS_EXPR:
11916 case LSHIFT_EXPR:
11917 case RSHIFT_EXPR:
11918 case URSHIFT_EXPR:
11919 case BIT_AND_EXPR:
11920 case BIT_XOR_EXPR:
11921 case BIT_IOR_EXPR:
11922 case TRUNC_MOD_EXPR:
11923 case TRUNC_DIV_EXPR:
11924 case RDIV_EXPR:
11925 case TRUTH_ANDIF_EXPR:
11926 case TRUTH_ORIF_EXPR:
11927 case EQ_EXPR:
11928 case NE_EXPR:
11929 case GT_EXPR:
11930 case GE_EXPR:
11931 case LT_EXPR:
11932 case LE_EXPR:
11933 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
11934 knows how to handle those cases. */
11939 /* Don't complete string nodes if dealing with the PLUS operand. */
11941 {
11944 return error_mark_node;
11947 }
11949 {
11952 return error_mark_node;
11955 }
11958 case INSTANCEOF_EXPR:
11962 {
11964 return node;
11965 }
11968 case UNARY_PLUS_EXPR:
11969 case NEGATE_EXPR:
11970 case TRUTH_NOT_EXPR:
11971 case BIT_NOT_EXPR:
11972 case PREDECREMENT_EXPR:
11973 case PREINCREMENT_EXPR:
11974 case POSTDECREMENT_EXPR:
11975 case POSTINCREMENT_EXPR:
11976 case CONVERT_EXPR:
11977 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
11978 how to handle those cases. */
11983 return error_mark_node;
11986 break;
11988 case ARRAY_REF:
11989 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
11990 how to handle those cases. */
11994 return error_mark_node;
11997 /* The same applies to wfl_op2 */
12001 return error_mark_node;
12006 case RECORD_TYPE:
12007 return node;;
12009 case COMPONENT_REF:
12010 /* The first step in the re-write of qualified name handling. FIXME.
12011 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12014 {
12018 {
12020 return error_mark_node;
12021 }
12023 {
12025 return error_mark_node;
12026 }
12027 return field;
12028 }
12029 else
12030 abort ();
12031 break;
12033 case THIS_EXPR:
12034 /* Can't use THIS in a static environment */
12036 {
12041 return error_mark_node;
12042 }
12044 {
12046 parse_error_context
12047 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12049 return error_mark_node;
12050 }
12051 return current_this;
12053 case CLASS_LITERAL:
12057 return error_mark_node;
12058 break;
12060 default:
12062 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12063 and it's time to turn it into the appropriate String object */
12066 else
12068 }
12069 return node;
12070 }
12072 /* Complete function call's argument. Return a non zero value is an
12073 error was found. */
12075 static int
12077 tree node;
12078 {
12080 tree cn;
12084 {
12089 {
12091 continue;
12092 }
12093 /* If have a string literal that we haven't transformed yet or a
12094 crafted string buffer, as a result of use of the the String
12095 `+' operator. Build `parm.toString()' and expand it. */
12098 /* Inline PRIMTYPE.TYPE read access */
12102 }
12104 return flag;
12105 }
12107 /* Sometimes (for loops and variable initialized during their
12108 declaration), we want to wrap a statement around a WFL and turn it
12109 debugable. */
12111 static tree
12114 tree stmt;
12115 {
12117 {
12120 }
12122 return stmt;
12123 }
12125 static tree
12128 {
12135 return node;
12136 }
12138 /* Create a new function block and link it approriately to current
12139 function block chain */
12141 static tree
12142 enter_block ()
12143 {
12146 /* Link block B supercontext to the previous block. The current
12147 function DECL is used as supercontext when enter_a_block is called
12148 for the first time for a given function. The current function body
12149 (DECL_FUNCTION_BODY) is set to be block B. */
12156 }
12159 {
12162 }
12163 else
12164 {
12167 }
12168 return b;
12169 }
12171 /* Exit a block by changing the current function body
12172 (DECL_FUNCTION_BODY) to the current block super context, only if
12173 the block being exited isn't the method's top level one. */
12175 static tree
12176 exit_block ()
12177 {
12178 tree b;
12180 {
12184 }
12185 else
12186 {
12191 }
12192 return b;
12193 }
12195 /* Lookup for NAME in the nested function's blocks, all the way up to
12196 the current toplevel one. It complies with Java's local variable
12197 scoping rules. */
12199 static tree
12201 tree name;
12202 {
12206 {
12207 tree current;
12209 /* Paranoid sanity check. To be removed */
12211 abort ();
12216 return current;
12218 }
12219 return NULL_TREE;
12220 }
12222 static void
12223 maybe_absorb_scoping_blocks ()
12224 {
12226 {
12230 }
12231 }
12233 \f
12234 /* This section of the source is reserved to build_* functions that
12235 are building incomplete tree nodes and the patch_* functions that
12236 are completing them. */
12238 /* Wrap a non WFL node around a WFL. */
12240 static tree
12242 tree node;
12244 {
12247 /* We want to process THIS . xxx symbolicaly, to keep it consistent
12248 with the way we're processing SUPER. A THIS from a primary as a
12249 different form than a SUPER. Turn THIS into something symbolic */
12252 else
12257 return wfl;
12258 }
12260 /* Build a super() constructor invocation. Returns empty_stmt_node if
12261 we're currently dealing with the class java.lang.Object. */
12263 static tree
12265 tree mdecl;
12266 {
12268 return empty_stmt_node;
12269 else
12270 {
12273 /* If we're dealing with an anonymous class, pass the arguments
12274 of the crafted constructor along. */
12276 {
12280 }
12282 }
12283 }
12285 /* Build a SUPER/THIS qualified method invocation. */
12287 static tree
12292 {
12293 tree invok;
12294 tree wfl =
12299 }
12301 /* Build an incomplete CALL_EXPR node. */
12303 static tree
12305 tree name;
12306 tree args;
12307 {
12311 return call;
12312 }
12314 /* Build an incomplete new xxx(...) node. */
12316 static tree
12319 {
12323 return call;
12324 }
12326 /* Build an incomplete assignment expression. */
12328 static tree
12332 {
12333 tree assignment;
12334 /* Build the corresponding binop if we deal with a Compound
12335 Assignment operator. Mark the binop sub-tree as part of a
12336 Compound Assignment expression */
12338 {
12341 }
12345 return assignment;
12346 }
12348 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
12352 tree node;
12353 {
12363 {
12367 }
12368 else
12372 return buffer;
12373 }
12375 \f
12377 /* This section of the code handle assignment check with FINAL
12378 variables. */
12380 static void
12382 tree class;
12383 {
12384 tree field;
12388 }
12390 /* Figure whether all final static variable have been initialized. */
12392 static void
12394 tree class;
12395 {
12396 tree field;
12401 parse_error_context
12405 }
12407 /* This function marks all final variable locally unassigned. */
12409 static void
12411 tree class;
12412 {
12413 tree field;
12417 }
12419 /* Figure whether all final variables have beem initialized in MDECL
12420 and mark MDECL accordingly. */
12422 static void
12424 tree class;
12425 tree mdecl;
12426 {
12427 tree field;
12432 return;
12434 /* First find out whether all final variables or no final variable
12435 are initialized in this ctor. We don't take into account final
12436 variable that have been initialized upon declaration. */
12439 {
12441 initialized++;
12442 else
12443 non_initialized++;
12444 }
12446 /* There were no non initialized variable and no initialized variable.
12447 This ctor is fine. */
12450 /* If no variables have been initialized, that fine. We'll check
12451 later whether this ctor calls a constructor which initializes
12452 them. We mark the ctor as not initializing all its finals. */
12455 /* If we have a mixed bag, then we have a problem. We need to report
12456 all the variables we're not initializing. */
12458 {
12463 {
12464 parse_error_context
12469 }
12470 }
12471 /* Otherwise we know this ctor is initializing all its final
12472 variable. We mark it so. */
12473 else
12475 }
12477 /* This function recurses in a simple what through STMT and stops when
12478 it finds a constructor call. It then verifies that the called
12479 constructor initialized its final properly. Return 1 upon success,
12480 0 or -1 otherwise. */
12482 static int
12484 tree stmt;
12485 {
12488 {
12489 case EXPR_WITH_FILE_LOCATION:
12491 case COMPOUND_EXPR:
12494 return res;
12496 case SAVE_EXPR:
12498 case CALL_EXPR:
12499 {
12501 tree fbody;
12506 abort ();
12516 }
12517 default:
12518 break;
12519 }
12521 }
12523 /* This is the last chance to catch a final variable initialization
12524 problem. This routine will report an error if a final variable was
12525 never (globally) initialized and never reported as not having been
12526 initialized properly. */
12528 static void
12530 tree class;
12531 {
12535 /* We go through all natural ctors and see whether they're
12536 initializing all their final variables or not. */
12540 {
12542 {
12543 /* It doesn't. Maybe it calls a constructor that initializes
12544 them. find out. */
12547 continue;
12550 {
12552 nnctor++;
12553 }
12554 else
12555 parse_error_context
12558 }
12559 else
12560 nnctor++;
12561 }
12563 /* Finally we catch final variables that never were initialized */
12566 /* If the field wasn't initialized upon declaration */
12568 /* There wasn't natural ctor in which the field could have been
12569 initialized */
12570 && !nnctor
12571 /* If we never reported a problem with this field */
12573 {
12575 parse_error_context
12579 }
12581 }
12583 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12584 context. */
12586 static int
12589 {
12600 /* Now the logic. We can modify a final VARIABLE:
12601 1) in finit$, (its declaration was followed by an initialization,)
12602 2) consistently in each natural ctor, if it wasn't initialized in
12603 finit$ or once in <clinit>. In any other cases, an error should be
12604 reported. */
12606 {
12609 }
12612 /* Only if it wasn't given a value upon initialization */
12614 /* If it was never assigned a value in this constructor */
12616 {
12617 /* Turn the locally assigned flag on, it will be checked later
12618 on to point out at discrepancies. */
12623 }
12625 /* Other problems should be reported right away. */
12626 parse_error_context
12631 /* Note that static field can be initialized once and only once. */
12636 }
12638 /* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
12639 read. This is needed to avoid circularities in the implementation
12640 of these fields in libjava. */
12642 static tree
12645 {
12649 {
12656 {
12660 }
12661 }
12663 }
12665 /* 15.25 Assignment operators. */
12667 static tree
12669 tree node;
12670 tree wfl_op1;
12671 tree wfl_op2;
12672 {
12679 /* Can't assign to a (blank) final. */
12685 /* Lhs can be a named variable */
12687 {
12689 }
12690 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
12691 comment on reason why */
12693 {
12696 }
12697 /* Or a field access */
12700 /* Or a function return slot */
12703 /* Otherwise, we might want to try to write into an optimized static
12704 final, this is an of a different nature, reported further on. */
12707 {
12709 {
12710 /* What we should do instead is resetting the all the flags
12711 previously set, exchange lvalue for llvalue and continue. */
12713 return error_mark_node;
12714 }
12715 else
12717 }
12718 else
12719 {
12722 }
12725 /* 5.1 Try the assignment conversion for builtin type. */
12728 /* 5.2 If it failed, try a reference conversion */
12732 /* 15.25.2 If we have a compound assignment, convert RHS into the
12733 type of the LHS */
12737 /* Explicit cast required. This is an error */
12739 {
12742 tree wfl;
12745 /* If the assignment is part of a declaration, we use the WFL of
12746 the declared variable to point out the error and call it a
12747 declaration problem. If the assignment is a genuine =
12748 operator, we call is a operator `=' problem, otherwise we
12749 call it an assignment problem. In both of these last cases,
12750 we use the WFL of the operator to indicate the error. */
12753 {
12756 }
12757 else
12758 {
12764 else
12766 }
12769 parse_error_context
12772 else
12773 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12777 }
12779 /* Inline read access to java.lang.PRIMTYPE.TYPE */
12784 return error_mark_node;
12786 /* 10.10: Array Store Exception runtime check */
12787 if (!flag_emit_class_files
12788 && !flag_emit_xref
12789 && lvalue_from_array
12791 {
12792 tree check;
12795 /* We need to retrieve the right argument for
12796 _Jv_CheckArrayStore. This is somewhat complicated by bounds
12797 and null pointer checks, both of which wrap the operand in
12798 one layer of COMPOUND_EXPR. */
12801 else
12802 {
12805 /* We can have a SAVE_EXPR here when doing String +=. */
12810 else
12812 }
12814 /* Build the invocation of _Jv_CheckArrayStore */
12820 NULL_TREE);
12823 /* We have to decide on an insertion point */
12825 {
12826 tree t;
12828 {
12832 }
12833 else
12836 }
12838 {
12844 {
12847 }
12849 /* Find the array bound check, hook the original array access. */
12853 /* Make sure the bound check will happen before the store check */
12854 new_compound =
12857 /* Re-assemble the augmented array access. */
12859 }
12860 else
12862 }
12864 /* Final locals can be used as case values in switch
12865 statement. Prepare them for this eventuality. */
12871 )
12872 {
12875 }
12880 return node;
12881 }
12883 /* Check that type SOURCE can be cast into type DEST. If the cast
12884 can't occur at all, return 0 otherwise 1. This function is used to
12885 produce accurate error messages on the reasons why an assignment
12886 failed. */
12888 static tree
12891 {
12896 {
12897 /* `null' may be assigned to any reference type */
12900 /* Try the reference assignment conversion */
12903 /* This is a magic assignment that we process differently */
12906 }
12907 return new_rhs;
12908 }
12910 /* Check that RHS can be converted into LHS_TYPE by the assignment
12911 conversion (5.2), for the cases of RHS being a builtin type. Return
12912 NULL_TREE if the conversion fails or if because RHS isn't of a
12913 builtin type. Return a converted RHS if the conversion is possible. */
12915 static tree
12918 {
12922 /* Handle boolean specially. */
12925 {
12929 }
12931 /* Zero accepted everywhere */
12937 /* 5.1.1 Try Identity Conversion,
12938 5.1.2 Try Widening Primitive Conversion */
12942 /* Try a narrowing primitive conversion (5.1.3):
12943 - expression is a constant expression of type int AND
12944 - variable is byte, short or char AND
12945 - The value of the expression is representable in the type of the
12946 variable */
12950 {
12954 parse_warning_context
12957 /* Reported a warning that will turn into an error further
12958 down, so we don't return */
12959 }
12961 return new_rhs;
12962 }
12964 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12965 conversion (5.1.1) or widening primitive conversion (5.1.2). Return
12966 0 is the conversion test fails. This implements parts the method
12967 invocation convertion (5.3). */
12969 static int
12972 {
12973 /* 5.1.1: This is the identity conversion part. */
12977 /* Reject non primitive types and boolean conversions. */
12981 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12982 than a char can't be converted into a char. Short can't too, but
12983 the < test below takes care of that */
12987 /* Accept all promoted type here. Note, we can't use <= in the test
12988 below, because we still need to bounce out assignments of short
12989 to char and the likes */
12992 || rhs_type == promoted_short_type_node
12993 || rhs_type == promoted_char_type_node
12997 /* From here, an integral is widened if its precision is smaller
12998 than the precision of the LHS or if the LHS is a floating point
12999 type, or the RHS is a float and the RHS a double. */
13007 }
13009 /* Check that something of SOURCE type can be assigned or cast to
13010 something of DEST type at runtime. Return 1 if the operation is
13011 valid, 0 otherwise. If CAST is set to 1, we're treating the case
13012 were SOURCE is cast into DEST, which borrows a lot of the
13013 assignment check. */
13015 static int
13017 tree source;
13018 tree dest;
13020 {
13021 /* SOURCE or DEST might be null if not from a declared entity. */
13031 /* If source and dest are being compiled from bytecode, they may need to
13032 be loaded. */
13034 {
13037 }
13039 {
13042 }
13044 /* Case where SOURCE is a class type */
13046 {
13052 {
13053 /* If doing a cast and SOURCE is final, the operation is
13054 always correct a compile time (because even if SOURCE
13055 does not implement DEST, a subclass of SOURCE might). */
13058 /* Otherwise, SOURCE must implement DEST */
13060 }
13061 /* DEST is an array, cast permited if SOURCE is of Object type */
13063 }
13065 {
13067 {
13068 /* If not casting, DEST must be the Object type */
13071 /* We're doing a cast. The cast is always valid is class
13072 DEST is not final, otherwise, DEST must implement SOURCE */
13075 else
13077 }
13079 {
13080 /* If doing a cast, then if SOURCE and DEST contain method
13081 with the same signature but different return type, then
13082 this is a (compile time) error */
13084 {
13086 tree source_type;
13087 tree source_sig;
13088 tree source_name;
13091 {
13092 source_sig =
13103 }
13105 }
13106 else
13108 }
13109 else
13110 {
13111 /* Array */
13112 return (cast
13116 }
13117 }
13119 {
13122 /* Can't cast an array to an interface unless the interface is
13123 java.lang.Cloneable or java.io.Serializable. */
13127 else /* Arrays */
13128 {
13132 /* In case of severe errors, they turn out null */
13139 }
13141 }
13143 }
13145 static int
13147 tree source;
13148 tree dest;
13149 {
13166 }
13168 static tree
13170 tree arg;
13171 {
13176 return arg;
13177 }
13179 /* Return a non zero value if SOURCE can be converted into DEST using
13180 the method invocation conversion rule (5.3). */
13181 static int
13184 {
13190 }
13192 /* Build an incomplete binop expression. */
13194 static tree
13199 {
13202 /* Store the location of the operator, for better error report. The
13203 string of the operator will be rebuild based on the OP value. */
13205 return binop;
13206 }
13208 /* Build the string of the operator retained by NODE. If NODE is part
13209 of a compound expression, add an '=' at the end of the string. This
13210 function is called when an error needs to be reported on an
13211 operator. The string is returned as a pointer to a static character
13212 buffer. */
13216 tree node;
13217 {
13218 #define BUILD_OPERATOR_STRING(S) \
13219 { \
13221 return buffer; \
13222 }
13226 {
13254 default:
13257 }
13258 return NULL;
13259 #undef BUILD_OPERATOR_STRING
13260 }
13262 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
13264 static int
13267 {
13276 }
13278 /* Return a non zero value if CODE is one of the operators that can be
13279 used in conjunction with the `=' operator in a compound assignment. */
13281 static int
13284 {
13288 break;
13291 }
13293 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
13295 static tree
13297 tree t;
13298 {
13302 return t;
13308 return t;
13310 /* Now the left branch of the binary operator. */
13314 return t;
13319 return t;
13323 /* It's got to be the an equivalent decl */
13325 {
13326 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13328 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13330 /* Change the right part of the BINOP_EXPR */
13332 }
13334 return t;
13335 }
13337 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13338 errors but we modify NODE so that it contains the type computed
13339 according to the expression, when it's fixed. Otherwise, we write
13340 error_mark_node as the type. It allows us to further the analysis
13341 of remaining nodes and detects more errors in certain cases. */
13343 static tree
13345 tree node;
13346 tree wfl_op1;
13347 tree wfl_op2;
13348 {
13356 /* If 1, tell the routine that we have to return error_mark_node
13357 after checking for the initialization of the RHS */
13362 /* If either op<n>_type are NULL, this might be early signs of an
13363 error situation, unless it's too early to tell (in case we're
13364 handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13365 correctly so the error can be later on reported accurately. */
13368 {
13369 tree n;
13371 {
13374 }
13376 {
13379 }
13380 }
13383 {
13384 /* 15.16 Multiplicative operators */
13390 {
13397 break;
13398 }
13400 /* Change the division operator if necessary */
13405 && flag_use_divide_subroutine
13406 && ! flag_emit_class_files
13410 /* This one is more complicated. FLOATs are processed by a
13411 function call to soft_fmod. Duplicate the value of the
13412 COMPOUND_ASSIGN_P flag. */
13414 {
13419 return mod;
13420 }
13421 break;
13423 /* 15.17 Additive Operators */
13426 /* Operation is valid if either one argument is a string
13427 constant, a String object or a StringBuffer crafted for the
13428 purpose of the a previous usage of the String concatenation
13429 operator */
13440 Numeric Types */
13442 {
13449 break;
13450 }
13452 break;
13454 /* 15.18 Shift Operators */
13455 case LSHIFT_EXPR:
13456 case RSHIFT_EXPR:
13457 case URSHIFT_EXPR:
13459 {
13462 else
13463 {
13466 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13469 else
13474 }
13477 break;
13478 }
13480 /* Unary numeric promotion (5.6.1) is performed on each operand
13481 separatly */
13485 /* The type of the shift expression is the type of the promoted
13486 type of the left-hand operand */
13489 /* Shift int only up to 0x1f and long up to 0x3f */
13493 else
13497 /* The >>> operator is a >> operating on unsigned quantities */
13499 {
13500 tree to_return;
13508 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13512 return to_return;
13513 }
13514 break;
13516 /* 15.19.1 Type Comparison Operator instaceof */
13517 case INSTANCEOF_EXPR:
13522 return error_mark_node;
13524 /* The first operand must be a reference type or the null type */
13528 /* The second operand must be a reference type */
13530 {
13532 parse_error_context
13536 }
13539 {
13540 /* If the first operand is null, the result is always false */
13542 return boolean_false_node;
13544 {
13547 return node;
13548 }
13549 /* Otherwise we have to invoke instance of to figure it out */
13550 else
13552 }
13553 /* There is no way the expression operand can be an instance of
13554 the type operand. This is a compile time error. */
13555 else
13556 {
13559 parse_error_context
13564 }
13566 break;
13568 /* 15.21 Bitwise and Logical Operators */
13569 case BIT_AND_EXPR:
13570 case BIT_XOR_EXPR:
13571 case BIT_IOR_EXPR:
13573 /* Binary numeric promotion is performed on both operand and the
13574 expression retain that type */
13579 /* The type of the bitwise operator expression is BOOLEAN */
13581 else
13582 {
13589 /* Insert a break here if adding thing before the switch's
13590 break for this case */
13591 }
13592 break;
13594 /* 15.22 Conditional-And Operator */
13595 case TRUTH_ANDIF_EXPR:
13596 /* 15.23 Conditional-Or Operator */
13597 case TRUTH_ORIF_EXPR:
13598 /* Operands must be of BOOLEAN type */
13601 {
13608 break;
13609 }
13610 /* The type of the conditional operators is BOOLEAN */
13612 break;
13614 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13615 case LT_EXPR:
13616 case GT_EXPR:
13617 case LE_EXPR:
13618 case GE_EXPR:
13619 /* The type of each of the operands must be a primitive numeric
13620 type */
13622 {
13629 break;
13630 }
13631 /* Binary numeric promotion is performed on the operands */
13633 /* The type of the relation expression is always BOOLEAN */
13635 break;
13637 /* 15.20 Equality Operator */
13638 case EQ_EXPR:
13639 case NE_EXPR:
13640 /* It's time for us to patch the strings. */
13642 {
13645 }
13647 {
13650 }
13652 /* 15.20.1 Numerical Equality Operators == and != */
13653 /* Binary numeric promotion is performed on the operands */
13657 /* 15.20.2 Boolean Equality Operators == and != */
13662 /* 15.20.3 Reference Equality Operators == and != */
13663 /* Types have to be either references or the null type. If
13664 they're references, it must be possible to convert either
13665 type to the other by casting conversion. */
13673 /* Else we have an error figure what can't be converted into
13674 what and report the error */
13675 else
13676 {
13679 parse_error_context
13687 break;
13688 }
13690 break;
13691 }
13694 return error_mark_node;
13702 return node;
13704 /* fold does not respect side-effect order as required for Java but not C.
13705 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13706 * bytecode.
13707 */
13711 return node;
13712 }
13714 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13715 zero value, the value of CSTE comes after the valude of STRING */
13717 static tree
13719 tree cste;
13722 {
13729 {
13732 }
13733 else
13734 {
13737 }
13740 }
13742 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13743 new STRING_CST on success, NULL_TREE on failure */
13745 static tree
13749 {
13750 /* Handle two string constants right away */
13755 /* Reasonable integer constant can be treated right away */
13757 {
13771 {
13775 }
13776 else
13780 }
13781 return NULL_TREE;
13782 }
13784 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13785 has to be a STRING_CST and the other part must be a STRING_CST or a
13786 INTEGRAL constant. Return a new STRING_CST if the operation
13787 succeed, NULL_TREE otherwise.
13789 If the case we want to optimize for space, we might want to return
13790 NULL_TREE for each invocation of this routine. FIXME */
13792 static tree
13795 {
13797 {
13805 /* Walk REST, only if it looks reasonable */
13810 {
13813 return error_mark_node;
13815 }
13817 }
13818 return NULL_TREE;
13819 }
13821 /* Implement the `+' operator. Does static optimization if possible,
13822 otherwise create (if necessary) and append elements to a
13823 StringBuffer. The StringBuffer will be carried around until it is
13824 used for a function call or an assignment. Then toString() will be
13825 called on it to turn it into a String object. */
13827 static tree
13830 {
13831 tree result;
13837 /* Try to do some static optimization */
13839 return result;
13841 /* Discard empty strings on either side of the expression */
13843 {
13846 }
13850 /* If operands are string constant, turn then into object references */
13856 /* If either one of the constant is null and the other non null
13857 operand is a String object, return it. */
13859 return op1;
13861 /* If OP1 isn't already a StringBuffer, create and
13862 initialize a new one */
13864 {
13865 /* Two solutions here:
13866 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13867 2) OP1 is something else, we call new StringBuffer().append(OP1). */
13870 else
13871 {
13874 }
13875 }
13878 {
13879 /* OP1 is no longer the last node holding a crafted StringBuffer */
13881 /* Create a node for `{new...,xxx}.append (op2)' */
13884 }
13886 /* Mark the last node holding a crafted StringBuffer */
13890 return op1;
13891 }
13893 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13894 StringBuffer. If no string were found to be patched, return
13895 NULL. */
13897 static tree
13899 tree node;
13900 {
13902 return error_mark_node;
13906 {
13909 tree ret;
13910 /* Temporary disable forbid the use of `this'. */
13913 /* String concatenation arguments must be evaluated in order too. */
13915 /* Restore it at its previous value */
13917 return ret;
13918 }
13919 return NULL_TREE;
13920 }
13922 /* Build the internal representation of a string constant. */
13924 static tree
13926 tree node;
13927 {
13930 {
13934 }
13937 return node;
13938 }
13940 /* Build an incomplete unary operator expression. */
13942 static tree
13945 tree op1;
13946 {
13948 tree unaryop;
13950 {
13956 }
13960 /* Store the location of the operator, for better error report. The
13961 string of the operator will be rebuild based on the OP value. */
13963 return unaryop;
13964 }
13966 /* Special case for the ++/-- operators, since they require an extra
13967 argument to build, which is set to NULL and patched
13968 later. IS_POST_P is 1 if the operator, 0 otherwise. */
13970 static tree
13973 tree op1;
13975 {
13977 {
13980 };
13984 /* Store the location of the operator, for better error report. The
13985 string of the operator will be rebuild based on the OP value. */
13987 return node;
13988 }
13990 /* Build an incomplete cast operator, based on the use of the
13991 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13992 set. java_complete_tree is trained to walk a CONVERT_EXPR even
13993 though its type is already set. */
13995 static tree
13999 {
14002 return node;
14003 }
14005 /* Build an incomplete class reference operator. */
14006 static tree
14009 tree class_name;
14010 {
14013 return node;
14014 }
14016 /* Complete an incomplete class reference operator. */
14017 static tree
14019 tree node;
14020 {
14022 tree ref_type;
14025 return error_mark_node;
14028 {
14030 /* A class referenced by `foo.class' is initialized. */
14034 }
14036 /* If we're emitting class files and we have to deal with non
14037 primitive types, we invoke (and consider generating) the
14038 synthetic static method `class$'. */
14043 }
14045 /* 15.14 Unary operators. We return error_mark_node in case of error,
14046 but preserve the type of NODE if the type is fixed. */
14048 static tree
14050 tree node;
14051 tree wfl_op;
14052 {
14063 {
14064 /* 15.13.2 Postfix Increment Operator ++ */
14065 case POSTINCREMENT_EXPR:
14066 /* 15.13.3 Postfix Increment Operator -- */
14067 case POSTDECREMENT_EXPR:
14068 /* 15.14.1 Prefix Increment Operator ++ */
14069 case PREINCREMENT_EXPR:
14070 /* 15.14.2 Prefix Decrement Operator -- */
14071 case PREDECREMENT_EXPR:
14074 /* We might be trying to change an outer field accessed using
14075 access method. */
14077 {
14078 /* Retrieve the decl of the field we're trying to access. We
14079 do that by first retrieving the function we would call to
14080 access the field. It has been already verified that this
14081 field isn't final */
14084 else
14087 }
14088 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14096 {
14097 tree lvalue;
14098 /* Before screaming, check that we're not in fact trying to
14099 increment a optimized static final access, in which case
14100 we issue an different error message. */
14108 }
14113 /* From now on, we know that op if a variable and that it has a
14114 valid wfl. We use wfl_op to locate errors related to the
14115 ++/-- operand. */
14117 {
14118 parse_error_context
14123 }
14124 else
14125 {
14126 /* Before the addition, binary numeric promotion is performed on
14127 both operands, if really necessary */
14129 {
14132 }
14133 else
14134 {
14139 }
14141 /* We remember we might be accessing an outer field */
14143 {
14144 /* We re-generate an access to the field */
14148 /* And we patch the original access$() into a write
14149 with plus_op as a rhs */
14151 }
14153 /* And write back into the node. */
14156 /* Convert the overall back into its original type, if
14157 necessary, and return */
14160 else
14162 }
14163 break;
14165 /* 15.14.3 Unary Plus Operator + */
14166 case UNARY_PLUS_EXPR:
14167 /* 15.14.4 Unary Minus Operator - */
14168 case NEGATE_EXPR:
14170 {
14174 }
14175 /* Unary numeric promotion is performed on operand */
14176 else
14177 {
14182 }
14183 break;
14185 /* 15.14.5 Bitwise Complement Operator ~ */
14186 case BIT_NOT_EXPR:
14188 {
14192 }
14193 else
14194 {
14197 }
14198 break;
14200 /* 15.14.6 Logical Complement Operator ! */
14201 case TRUTH_NOT_EXPR:
14203 {
14205 /* But the type is known. We will report an error if further
14206 attempt of a assignment is made with this rhs */
14209 }
14210 else
14212 break;
14214 /* 15.15 Cast Expression */
14215 case CONVERT_EXPR:
14218 {
14219 /* If this cast is part of an assignment, we tell the code
14220 that deals with it not to complain about a mismatch,
14221 because things have been cast, anyways */
14224 }
14225 else
14226 {
14229 return value;
14230 }
14231 break;
14232 }
14235 return error_mark_node;
14237 /* There are cases where node has been replaced by something else
14238 and we don't end up returning here: UNARY_PLUS_EXPR,
14239 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14244 }
14246 /* Generic type resolution that sometimes takes place during node
14247 patching. Returned the resolved type or generate an error
14248 message. Return the resolved type or NULL_TREE. */
14250 static tree
14252 tree type;
14253 {
14255 {
14258 {
14262 return NULL_TREE;
14263 }
14265 }
14266 return type;
14267 }
14268 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14269 found. Otherwise NODE or something meant to replace it is returned. */
14271 static tree
14273 tree node;
14274 tree wfl_op;
14275 {
14281 /* First resolve OP_TYPE if unresolved */
14283 return error_mark_node;
14285 /* Check on cast that are proven correct at compile time */
14287 {
14288 /* Same type */
14290 return node;
14292 /* float and double type are converted to the original type main
14293 variant and then to the target type. */
14297 /* Try widening/narowwing convertion. Potentially, things need
14298 to be worked out in gcc so we implement the extreme cases
14299 correctly. fold_convert() needs to be fixed. */
14301 }
14303 /* It's also valid to cast a boolean into a boolean */
14305 return node;
14307 /* null can be casted to references */
14311 /* The remaining legal casts involve conversion between reference
14312 types. Check for their compile time correctness. */
14315 {
14317 /* Now, the case can be determined correct at compile time if
14318 OP_TYPE can be converted into CAST_TYPE by assignment
14319 conversion (5.2) */
14322 {
14324 return node;
14325 }
14328 {
14330 return node;
14331 }
14333 /* The cast requires a run-time check */
14338 NULL_TREE);
14339 }
14341 /* Any other casts are proven incorrect at compile time */
14346 return error_mark_node;
14347 }
14349 /* Build a null constant and give it the type TYPE. */
14351 static tree
14353 tree type;
14354 {
14357 return node;
14358 }
14360 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14361 a list of indices. */
14362 static tree
14366 {
14369 return node;
14370 }
14372 /* 15.12 Array Access Expression */
14374 static tree
14376 tree node;
14377 {
14389 /* The array reference must be an array */
14391 {
14392 parse_error_context
14398 }
14400 /* The array index undergoes unary numeric promotion. The promoted
14401 type must be int */
14404 {
14409 else
14415 }
14418 return error_mark_node;
14423 {
14426 }
14427 else
14428 {
14429 /* The save_expr is for correct evaluation order. It would be cleaner
14430 to use force_evaluation_order (see comment there), but that is
14431 difficult when we also have to deal with bounds checking. */
14437 }
14439 return node;
14440 }
14442 /* 15.9 Array Creation Expressions */
14444 static tree
14446 tree type;
14447 tree dims;
14449 {
14450 tree node =
14453 return node;
14454 }
14456 static tree
14458 tree node;
14459 {
14467 /* Dimension types are verified. It's better for the types to be
14468 verified in order. */
14470 {
14474 /* Dim might have been saved during its evaluation */
14477 /* The type of each specified dimension must be an integral type. */
14481 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14482 promoted type must be int. */
14483 else
14484 {
14488 }
14490 /* Report errors on types here */
14492 {
14493 parse_error_context
14500 }
14503 }
14505 /* Resolve array base type if unresolved */
14510 {
14511 /* We don't want further evaluation of this bogus array creation
14512 operation */
14514 return error_mark_node;
14515 }
14517 /* Set array_type to the actual (promoted) array type of the result. */
14521 {
14523 }
14527 {
14529 array_type
14535 }
14538 /* The node is transformed into a function call. Things are done
14539 differently according to the number of dimensions. If the number
14540 of dimension is equal to 1, then the nature of the base type
14541 (primitive or not) matters. */
14545 /* Can't reuse what's already written in expr.c because it uses the
14546 JVM stack representation. Provide a build_multianewarray. FIXME */
14552 NULL_TREE);
14553 }
14555 /* 10.6 Array initializer. */
14557 /* Build a wfl for array element that don't have one, so we can
14558 pin-point errors. */
14560 static tree
14562 tree node;
14563 {
14567 else
14568 return NULL_TREE;
14569 }
14571 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14572 identification of initialized arrays easier to detect during walk
14573 and expansion. */
14575 static tree
14578 tree values;
14579 {
14583 return to_return;
14584 }
14586 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14587 occurred. Otherwise return NODE after having set its type
14588 appropriately. */
14590 static tree
14593 {
14596 HOST_WIDE_INT length;
14601 {
14605 return error_mark_node;
14606 }
14614 {
14617 {
14620 /* When compiling to native code, STRING_CST is converted to
14621 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14624 }
14625 else
14626 {
14630 }
14634 }
14637 return error_mark_node;
14639 /* Create a new type. We can't reuse the one we have here by
14640 patching its dimension because it originally is of dimension -1
14641 hence reused by gcc. This would prevent triangular arrays. */
14647 return node;
14648 }
14650 /* Verify that one entry of the initializer element list can be
14651 assigned to the array base type. Report 1 if an error occurred, 0
14652 otherwise. */
14654 static int
14657 {
14666 /* patch_string return error_mark_node if arg is error_mark_node */
14674 /* At anytime, try_builtin_assignconv can report a warning on
14675 constant overflow during narrowing. */
14681 /* Check and report errors */
14683 {
14688 parse_error_context
14692 }
14695 {
14698 }
14704 return error_seen;
14705 }
14707 static tree
14710 {
14714 return node;
14715 }
14717 /* 14.15 The return statement. It builds a modify expression that
14718 assigns the returned value to the RESULT_DECL that hold the value
14719 to be returned. */
14721 static tree
14724 tree op;
14725 {
14729 return node;
14730 }
14732 static tree
14734 tree node;
14735 {
14744 /* It's invalid to have a return value within a function that is
14745 declared with the keyword void or that is a constructor */
14749 /* It's invalid to use a return statement in a static block */
14753 /* It's invalid to have a no return value within a function that
14754 isn't declared with the keyword `void' */
14762 {
14772 {
14779 }
14780 else
14784 return error_mark_node;
14785 }
14787 /* If we have a return_exp, build a modify expression and expand
14788 it. Note: at that point, the assignment is declared valid, but we
14789 may want to carry some more hacks */
14791 {
14795 /* If the function returned value and EXP are booleans, EXP has
14796 to be converted into the type of DECL_RESULT, which is integer
14797 (see complete_start_java_method) */
14802 /* `null' can be assigned to a function returning a reference */
14815 {
14818 }
14819 else
14820 return error_mark_node;
14821 }
14824 return node;
14825 }
14827 /* 14.8 The if Statement */
14829 static tree
14833 {
14834 tree node;
14840 return node;
14841 }
14843 static tree
14845 tree node;
14846 {
14852 /* The type of expression must be boolean */
14855 {
14856 parse_error_context
14860 return error_mark_node;
14861 }
14868 return node;
14869 }
14871 /* 14.6 Labeled Statements */
14873 /* Action taken when a lableled statement is parsed. a new
14874 LABELED_BLOCK_EXPR is created. No statement is attached to the
14875 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
14877 static tree
14880 tree label;
14881 {
14882 tree label_name ;
14886 else
14887 {
14889 /* Issue an error if we try to reuse a label that was previously
14890 declared */
14892 {
14902 java_error_count--;
14903 }
14904 }
14910 return node;
14911 }
14913 /* A labeled statement LBE is attached a statement. */
14915 static tree
14918 tree statement;
14919 {
14920 /* In anyways, tie the loop to its statement */
14922 pop_labeled_block ();
14923 POP_LABELED_BLOCK ();
14924 return lbe;
14925 }
14927 /* 14.10, 14.11, 14.12 Loop Statements */
14929 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14930 list. */
14932 static tree
14934 tree loop_body;
14935 {
14939 return loop;
14940 }
14942 /* Create a loop body according to the following structure:
14943 COMPOUND_EXPR
14944 COMPOUND_EXPR (loop main body)
14945 EXIT_EXPR (this order is for while/for loops.
14946 LABELED_BLOCK_EXPR the order is reversed for do loops)
14947 LABEL_DECL (a continue occuring here branches at the
14948 BODY end of this labeled block)
14949 INCREMENT (if any)
14951 REVERSED, if non zero, tells that the loop condition expr comes
14952 after the body, like in the do-while loop.
14954 To obtain a loop, the loop body structure described above is
14955 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14957 LABELED_BLOCK_EXPR
14958 LABEL_DECL (use this label to exit the loop)
14959 LOOP_EXPR
14960 <structure described above> */
14962 static tree
14965 tree condition;
14967 {
14978 return
14981 }
14983 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14984 their order) on the current loop. Unlink the current loop from the
14985 loop list. */
14987 static tree
14992 {
14996 {
14998 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14999 The real EXIT_EXPR is one operand further. */
15001 /* This one is for accurate error reports */
15004 }
15006 POP_LOOP ();
15007 return to_return;
15008 }
15010 /* Tailored version of finish_loop_body for FOR loops, when FOR
15011 loops feature the condition part */
15013 static tree
15017 {
15018 /* Put the condition and the loop body in place */
15020 /* LOOP is the current loop which has been now popped of the loop
15021 stack. Install the update block */
15023 return loop;
15024 }
15026 /* Try to find the loop a block might be related to. This comprises
15027 the case where the LOOP_EXPR is found as the second operand of a
15028 COMPOUND_EXPR, because the loop happens to have an initialization
15029 part, then expressed as the first operand of the COMPOUND_EXPR. If
15030 the search finds something, 1 is returned. Otherwise, 0 is
15031 returned. The search is assumed to start from a
15032 LABELED_BLOCK_EXPR's block. */
15034 static tree
15036 tree statement;
15037 {
15039 return statement;
15043 else
15044 return NULL_TREE;
15052 }
15054 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15055 returned otherwise. */
15057 static int
15060 {
15071 }
15073 /* If the loop isn't surrounded by a labeled statement, create one and
15074 insert LOOP as its body. */
15076 static tree
15078 tree loop;
15079 {
15080 tree loop_label;
15084 return loop;
15087 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15088 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15091 return loop_label;
15092 }
15094 /* 14.13, 14.14: break and continue Statements */
15096 /* Build a break or a continue statement. a null NAME indicates an
15097 unlabeled break/continue statement. */
15099 static tree
15102 tree name;
15103 {
15107 {
15110 /* Null means that we don't have a target for this named
15111 break/continue. In this case, we make the target to be the
15112 label name, so that the error can be reported accuratly in
15113 patch_bc_statement. */
15115 }
15116 /* Unlabeled break/continue will be handled during the
15117 break/continue patch operation */
15118 break_continue
15125 return break_continue;
15126 }
15128 /* Verification of a break/continue statement. */
15130 static tree
15132 tree node;
15133 {
15138 /* Having an identifier here means that the target is unknown. */
15140 {
15143 return error_mark_node;
15144 }
15146 {
15147 /* It's a continue statement. */
15149 {
15151 {
15155 else
15156 parse_error_context
15159 return error_mark_node;
15160 }
15165 {
15167 break;
15168 }
15169 }
15170 }
15172 {
15174 {
15176 {
15179 return error_mark_node;
15180 }
15184 {
15186 break;
15187 }
15188 }
15189 }
15194 /* Our break/continue don't return values. */
15196 /* Encapsulate the break within a compound statement so that it's
15197 expanded all the times by expand_expr (and not clobbered
15198 sometimes, like after a if statement) */
15201 return node;
15202 }
15204 /* Process the exit expression belonging to a loop. Its type must be
15205 boolean. */
15207 static tree
15209 tree node;
15210 {
15215 /* The type of expression must be boolean */
15217 {
15218 parse_error_context
15222 return error_mark_node;
15223 }
15224 /* Now we know things are allright, invert the condition, fold and
15225 return */
15238 return node;
15239 }
15241 /* 14.9 Switch statement */
15243 static tree
15245 tree node;
15246 {
15249 /* Complete the switch expression */
15252 /* The type of the switch expression must be char, byte, short or
15253 int */
15255 {
15260 /* This is what java_complete_tree will check */
15262 return error_mark_node;
15263 }
15267 /* Ready to return */
15269 {
15271 return error_mark_node;
15272 }
15278 return node;
15279 }
15281 /* 14.18 The try/catch statements */
15283 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15284 catches TYPE and executes CATCH_STMTS. */
15286 static tree
15290 {
15293 /* First build a try block */
15296 /* Build a catch block: we need a catch clause parameter */
15299 /* And a block */
15302 /* Initialize the variable and store in the block */
15307 /* Add the catch statements */
15310 /* Now we can build a CATCH_EXPR */
15314 }
15316 static tree
15320 {
15323 return node;
15324 }
15326 static tree
15330 {
15333 return node;
15334 }
15336 static tree
15338 tree node;
15339 {
15342 /* Exception handlers are considered in left to right order */
15346 /* Check catch clauses, if any. Every time we find an error, we try
15347 to process the next catch clause. We process the catch clause before
15348 the try block so that when processing the try block we can check thrown
15349 exceptions againts the caught type list. */
15351 {
15356 /* At this point, the structure of the catch clause is
15357 CATCH_EXPR (catch node)
15358 BLOCK (with the decl of the parameter)
15359 COMPOUND_EXPR
15360 MODIFY_EXPR (assignment of the catch parameter)
15361 BLOCK (catch clause block)
15362 */
15367 /* Catch clauses can't have more than one parameter declared,
15368 but it's already enforced by the grammar. Make sure that the
15369 only parameter of the clause statement in of class Throwable
15370 or a subclass of Throwable, but that was done earlier. The
15371 catch clause parameter type has also been resolved. */
15373 /* Just make sure that the catch clause parameter type inherits
15374 from java.lang.Throwable */
15376 {
15379 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15382 continue;
15383 }
15385 /* Partial check for unreachable catch statement: The catch
15386 clause is reachable iff is no earlier catch block A in
15387 the try statement such that the type of the catch
15388 clause's parameter is the same as or a subclass of the
15389 type of A's parameter */
15393 {
15399 {
15401 parse_error_context
15406 break;
15407 }
15408 }
15409 /* Complete the catch clause block */
15412 {
15414 continue;
15415 }
15421 continue;
15423 /* Things to do here: the exception must be thrown */
15425 /* Link this type to the caught type list */
15427 }
15434 POP_EXCEPTIONS ();
15436 /* Verification ends here */
15438 return error_mark_node;
15443 return node;
15444 }
15446 /* 14.17 The synchronized Statement */
15448 static tree
15451 {
15458 {
15460 return expr;
15461 }
15463 /* We might be trying to synchronize on a STRING_CST */
15467 /* The TYPE of expr must be a reference type */
15469 {
15471 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15473 return error_mark_node;
15474 }
15477 {
15481 return node;
15482 }
15484 /* Generate a try-finally for the synchronized statement, except
15485 that the handler that catches all throw exception calls
15486 _Jv_MonitorExit and then rethrow the exception.
15487 The synchronized statement is then implemented as:
15488 TRY
15489 {
15490 _Jv_MonitorEnter (expression)
15491 synchronized_block
15492 _Jv_MonitorExit (expression)
15493 }
15494 CATCH_ALL
15495 {
15496 e = _Jv_exception_info ();
15497 _Jv_MonitorExit (expression)
15498 Throw (e);
15499 } */
15514 block));
15518 }
15520 /* 14.16 The throw Statement */
15522 static tree
15525 {
15530 /* Thrown expression must be assignable to java.lang.Throwable */
15532 {
15537 /* If the thrown expression was a reference, we further the
15538 compile-time check. */
15540 return error_mark_node;
15541 }
15543 /* At least one of the following must be true */
15545 /* The type of the throw expression is a not checked exception,
15546 i.e. is a unchecked expression. */
15550 /* An instance can't throw a checked exception unless that exception
15551 is explicitely declared in the `throws' clause of each
15552 constructor. This doesn't apply to anonymous classes, since they
15553 don't have declared constructors. */
15554 if (!unchecked_ok
15557 {
15558 tree current;
15563 {
15564 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)",
15566 return error_mark_node;
15567 }
15568 }
15570 /* Throw is contained in a try statement and at least one catch
15571 clause can receive the thrown expression or the current method is
15572 declared to throw such an exception. Or, the throw statement is
15573 contained in a method or constructor declaration and the type of
15574 the Expression is assignable to at least one type listed in the
15575 throws clause the declaration. */
15579 {
15580 /* If there is a surrounding try block that has no matching
15581 clatch clause, report it first. A surrounding try block exits
15582 only if there is something after the list of checked
15583 exception thrown by the current function (if any). */
15585 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15587 /* If we have no surrounding try statement and the method doesn't have
15588 any throws, report it now. FIXME */
15590 /* We report that the exception can't be throw from a try block
15591 in all circumstances but when the `throw' is inside a static
15592 block. */
15595 {
15600 else
15604 }
15605 /* Otherwise, the current method doesn't have the appropriate
15606 throws declaration */
15607 else
15608 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15610 return error_mark_node;
15611 }
15616 /* If doing xrefs, keep the location where the `throw' was seen. */
15619 return node;
15620 }
15622 /* Check that exception said to be thrown by method DECL can be
15623 effectively caught from where DECL is invoked. */
15625 static void
15628 tree decl;
15629 {
15630 tree throws;
15631 /* For all the unchecked exceptions thrown by DECL */
15635 {
15636 #if 1
15637 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
15639 continue;
15640 #endif
15643 parse_error_context
15646 else
15647 {
15648 parse_error_context
15649 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15654 }
15655 }
15656 }
15658 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15659 try-catch blocks, OR is listed in the `throws' clause of the
15660 current method. */
15662 static int
15664 tree exception;
15665 {
15668 /* First, all the nested try-catch-finally at that stage. The
15669 last element contains `throws' clause exceptions, if any. */
15673 {
15674 tree caught;
15679 }
15681 }
15683 static void
15685 tree mdecl;
15686 {
15691 {
15694 {
15697 }
15699 }
15700 /* List is inverted here, but it doesn't matter */
15702 }
15704 /* This function goes over all of CLASS_TYPE ctors and checks whether
15705 each of them features at least one unchecked exception in its
15706 `throws' clause. If it's the case, it returns `true', `false'
15707 otherwise. */
15709 static bool
15711 tree class_type;
15712 {
15713 tree current;
15717 {
15720 {
15721 tree throws;
15726 }
15727 /* We return false as we found one ctor that is unfit. */
15729 return false;
15730 }
15731 /* All ctors feature at least one unchecked exception in their
15732 `throws' clause. */
15733 return true;
15734 }
15736 /* 15.24 Conditional Operator ?: */
15738 static tree
15741 {
15749 /* Operands of ?: might be StringBuffers crafted as a result of a
15750 string concatenation. Obtain a descent operand here. */
15759 /* The first expression must be a boolean */
15761 {
15767 }
15769 /* Second and third can be numeric, boolean (i.e. primitive),
15770 references or null. Anything else results in an error */
15777 /* Determine the type of the conditional expression. Same types are
15778 easy to deal with */
15782 /* There are different rules for numeric types */
15784 {
15785 /* if byte/short found, the resulting type is short */
15790 /* If t1 is a constant int and t2 is of type byte, short or char
15791 and t1's value fits in t2, then the resulting type is t2 */
15796 /* If t2 is a constant int and t1 is of type byte, short or char
15797 and t2's value fits in t1, then the resulting type is t1 */
15802 /* Otherwise, binary numeric promotion is applied and the
15803 resulting type is the promoted type of operand 1 and 2 */
15804 else
15808 }
15810 /* Cases of a reference and a null type */
15817 /* Last case: different reference types. If a type can be converted
15818 into the other one by assignment conversion, the latter
15819 determines the type of the expression */
15826 /* If we don't have any resulting type, we're in trouble */
15828 {
15836 }
15839 {
15841 return error_mark_node;
15842 }
15847 return node;
15848 }
15850 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15852 static tree
15855 {
15858 return expr;
15862 {
15867 return expr;
15868 }
15871 }
15873 /* Try to constant fold NODE.
15874 If NODE is not a constant expression, return NULL_EXPR.
15875 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15877 static tree
15879 tree node;
15880 tree context;
15881 {
15886 {
15887 case STRING_CST:
15888 case INTEGER_CST:
15889 case REAL_CST:
15890 return node;
15892 case PLUS_EXPR:
15893 case MINUS_EXPR:
15894 case MULT_EXPR:
15895 case TRUNC_MOD_EXPR:
15896 case RDIV_EXPR:
15897 case LSHIFT_EXPR:
15898 case RSHIFT_EXPR:
15899 case URSHIFT_EXPR:
15900 case BIT_AND_EXPR:
15901 case BIT_XOR_EXPR:
15902 case BIT_IOR_EXPR:
15903 case TRUTH_ANDIF_EXPR:
15904 case TRUTH_ORIF_EXPR:
15905 case EQ_EXPR:
15906 case NE_EXPR:
15907 case GT_EXPR:
15908 case GE_EXPR:
15909 case LT_EXPR:
15910 case LE_EXPR:
15915 return NULL_TREE;
15919 return NULL_TREE;
15923 case UNARY_PLUS_EXPR:
15924 case NEGATE_EXPR:
15925 case TRUTH_NOT_EXPR:
15926 case BIT_NOT_EXPR:
15927 case CONVERT_EXPR:
15931 return NULL_TREE;
15934 break;
15936 case COND_EXPR:
15939 return NULL_TREE;
15943 return NULL_TREE;
15947 return NULL_TREE;
15952 case VAR_DECL:
15953 case FIELD_DECL:
15956 return NULL_TREE;
15958 /* Guard against infinite recursion. */
15964 return val;
15966 case EXPR_WITH_FILE_LOCATION:
15967 /* Compare java_complete_tree and resolve_expression_name. */
15970 {
15972 tree decl;
15974 return NULL_TREE;
15976 {
15980 return NULL_TREE;
15982 }
15983 else
15984 {
15985 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
15990 return NULL_TREE;
15991 }
15992 }
15993 else
15994 {
15998 return NULL_TREE;
16000 return val;
16001 }
16003 #ifdef USE_COMPONENT_REF
16004 case IDENTIFIER:
16005 case COMPONENT_REF:
16006 ?;
16007 #endif
16009 default:
16010 return NULL_TREE;
16011 }
16012 }
16014 #ifdef USE_COMPONENT_REF
16015 /* Context is 'T' for TypeName, 'P' for PackageName,
16016 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16018 tree
16020 tree name;
16022 {
16023 }
16025 tree
16027 tree name;
16029 {
16030 }
16031 #endif
16033 /* Mark P, which is really a `struct parser_ctxt **' for GC. */
16035 static void
16038 {
16043 return;
16045 #ifndef JC1_LITE
16065 }
16067 void
16068 init_src_parse ()
16069 {
16070 /* Register roots with the garbage collector. */
16072 }
16074 \f
16076 /* This section deals with the functions that are called when tables
16077 recording class initialization information are traversed. */
16079 /* Attach to PTR (a block) the declaration found in ENTRY. */
16081 static bool
16084 PTR ptr;
16085 {
16091 return true;
16092 }
16094 /* This function is called for each statement calling a static
16095 function. ENTRY is a TREE_LIST whose PURPOSE is the called
16096 function and VALUE is a compound whose second operand can be
16097 patched with static class initialization flag assignments. */
16099 static bool
16102 PTR info ATTRIBUTE_UNUSED;
16103 {
16109 /* For each class definitely initialized in CALLED_METHOD, fill
16110 ASSIGNMENT_COMPOUND with assignment to the class initialization flag. */
16117 return true;
16118 }
16120 /* This function is called for each classes that is known definitely
16121 assigned when a given static method was called. This function
16122 augments a compound expression (INFO) storing all assignment to
16123 initialized static class flags if a flag already existed, otherwise
16124 a new one is created. */
16126 static bool
16129 PTR info;
16130 {
16138 /* If we haven't found a flag and we're dealing with self registered
16139 with current_function_decl, then don't do anything. Self is
16140 always added as definitely initialized but this information is
16141 valid only if used outside the current function. */
16143 {
16148 else
16149 return true;
16150 }
16152 /* If we don't have a variable, create one and install it. */
16154 {
16155 tree block;
16163 /* The trick is to find the right context for it. */
16168 }
16169 else
16172 /* Now simply augment the compound that holds all the assignments
16173 pertaining to this method invocation. */
16179 return true;
16180 }