Subversion Repositories scarts

/* Source code parsing and tree node generation for the GNU compiler

   for the Java(TM) language.

   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005

   Free Software Foundation, Inc.

   Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

GCC is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING.  If not, write to

the Free Software Foundation, 51 Franklin Street, Fifth Floor,

Boston, MA 02110-1301, USA.

Java and all Java-based marks are trademarks or registered trademarks

of Sun Microsystems, Inc. in the United States and other countries.

The Free Software Foundation is independent of Sun Microsystems, Inc.  */

/* This file parses java source code and issues a tree node image

suitable for code generation (byte code and targeted CPU assembly

language).

The grammar conforms to the Java grammar described in "The Java(TM)

Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley

1996, ISBN 0-201-63451-1"

The following modifications were brought to the original grammar:

method_body: added the rule '| block SC_TK'

static_initializer: added the rule 'static block SC_TK'.

Note: All the extra rules described above should go away when the

      empty_statement rule will work.

statement_nsi: 'nsi' should be read no_short_if.

Some rules have been modified to support JDK1.1 inner classes

definitions and other extensions.  */

%{

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include 

#include "tree.h"

#include "rtl.h"

#include "real.h"

#include "obstack.h"

#include "toplev.h"

#include "pretty-print.h"

#include "diagnostic.h"

#include "flags.h"

#include "java-tree.h"

#include "jcf.h"

#include "lex.h"

#include "parse.h"

#include "zipfile.h"

#include "convert.h"

#include "buffer.h"

#include "function.h"

#include "except.h"

#include "ggc.h"

#include "debug.h"

#include "tree-inline.h"

#include "tree-dump.h"

#include "cgraph.h"

#include "target.h"

/* Local function prototypes */

static char *java_accstring_lookup (int);

static const char *accessibility_string (int);

static void  classitf_redefinition_error (const char *,tree, tree, tree);

static void  variable_redefinition_error (tree, tree, tree, int);

static tree  create_class (int, tree, tree, tree);

static tree  create_interface (int, tree, tree);

static void  end_class_declaration (int);

static tree  find_field (tree, tree);

static tree lookup_field_wrapper (tree, tree);

static int   duplicate_declaration_error_p (tree, tree, tree);

static void  register_fields (int, tree, tree);

static tree parser_qualified_classname (tree);

static int  parser_check_super (tree, tree, tree);

static int  parser_check_super_interface (tree, tree, tree);

static void check_modifiers_consistency (int);

static tree lookup_cl (tree);

static tree lookup_java_method2 (tree, tree, int);

static tree method_header (int, tree, tree, tree);

static void fix_method_argument_names (tree ,tree);

static tree method_declarator (tree, tree);

static void parse_warning_context (tree cl, const char *gmsgid, ...) ATTRIBUTE_GCC_DIAG(2,3);

#ifdef USE_MAPPED_LOCATION

static void issue_warning_error_from_context

  (source_location, const char *gmsgid, va_list *);

#else

static void issue_warning_error_from_context

  (tree, const char *gmsgid, va_list *);

#endif

static void parse_ctor_invocation_error (void);

static tree parse_jdk1_1_error (const char *);

static void complete_class_report_errors (jdep *);

static int process_imports (void);

static void read_import_dir (tree);

static int find_in_imports_on_demand (tree, tree);

static void find_in_imports (tree, tree);

static bool inner_class_accessible (tree, tree);

static void check_inner_class_access (tree, tree, tree);

static int check_pkg_class_access (tree, tree, bool, tree);

static tree resolve_package (tree, tree *, tree *);

static tree resolve_class (tree, tree, tree, tree);

static void declare_local_variables (int, tree, tree);

static void dump_java_tree (enum tree_dump_index, tree);

static void source_start_java_method (tree);

static void source_end_java_method (void);

static tree find_name_in_single_imports (tree);

static void check_abstract_method_header (tree);

static tree lookup_java_interface_method2 (tree, tree);

static tree resolve_expression_name (tree, tree *);

static tree maybe_create_class_interface_decl (tree, tree, tree, tree);

static int check_class_interface_creation (int, int, tree, tree, tree, tree);

static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);

static tree resolve_and_layout (tree, tree);

static tree qualify_and_find (tree, tree, tree);

static tree resolve_no_layout (tree, tree);

static int invocation_mode (tree, int);

static tree find_applicable_accessible_methods_list (int, tree, tree, tree);

static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);

static tree find_most_specific_methods_list (tree);

static int argument_types_convertible (tree, tree);

static tree patch_invoke (tree, tree, tree);

static int maybe_use_access_method (int, tree *, tree *);

static tree lookup_method_invoke (int, tree, tree, tree, tree);

static tree register_incomplete_type (int, tree, tree, tree);

static tree check_inner_circular_reference (tree, tree);

static tree check_circular_reference (tree);

static tree obtain_incomplete_type (tree);

static tree java_complete_lhs (tree);

static tree java_complete_tree (tree);

static tree maybe_generate_pre_expand_clinit (tree);

static int analyze_clinit_body (tree, tree);

static int maybe_yank_clinit (tree);

static void start_complete_expand_method (tree);

static void java_complete_expand_method (tree);

static void java_expand_method_bodies (tree);

static int  unresolved_type_p (tree, tree *);

static void create_jdep_list (struct parser_ctxt *);

static tree build_expr_block (tree, tree);

static tree enter_block (void);

static tree exit_block (void);

static tree lookup_name_in_blocks (tree);

static void maybe_absorb_scoping_blocks (void);

static tree build_method_invocation (tree, tree);

static tree build_new_invocation (tree, tree);

static tree build_assignment (int, int, tree, tree);

static tree build_binop (enum tree_code, int, tree, tree);

static tree patch_assignment (tree, tree);

static tree patch_binop (tree, tree, tree, int);

static tree build_unaryop (int, int, tree);

static tree build_incdec (int, int, tree, int);

static tree patch_unaryop (tree, tree);

static tree build_cast (int, tree, tree);

static tree build_null_of_type (tree);

static tree patch_cast (tree, tree);

static int valid_ref_assignconv_cast_p (tree, tree, int);

static int valid_builtin_assignconv_identity_widening_p (tree, tree);

static int valid_cast_to_p (tree, tree);

static int valid_method_invocation_conversion_p (tree, tree);

static tree try_builtin_assignconv (tree, tree, tree);

static tree try_reference_assignconv (tree, tree);

static tree build_unresolved_array_type (tree);

static int build_type_name_from_array_name (tree, tree *);

static tree build_array_from_name (tree, tree, tree, tree *);

static tree build_array_ref (int, tree, tree);

static tree patch_array_ref (tree);

#ifdef USE_MAPPED_LOCATION

static tree make_qualified_name (tree, tree, source_location);

#else

static tree make_qualified_name (tree, tree, int);

#endif

static tree merge_qualified_name (tree, tree);

static tree make_qualified_primary (tree, tree, int);

static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);

static void qualify_ambiguous_name (tree);

static tree resolve_field_access (tree, tree *, tree *);

static tree build_newarray_node (tree, tree, int);

static tree patch_newarray (tree);

static tree resolve_type_during_patch (tree);

static tree build_this (int);

static tree build_wfl_wrap (tree, int);

static tree build_return (int, tree);

static tree patch_return (tree);

static tree maybe_access_field (tree, tree, tree);

static int complete_function_arguments (tree);

static int check_for_static_method_reference (tree, tree, tree, tree, tree);

static int not_accessible_p (tree, tree, tree, int);

static void check_deprecation (tree, tree);

static int class_in_current_package (tree);

static tree build_if_else_statement (int, tree, tree, tree);

static tree patch_if_else_statement (tree);

static tree add_stmt_to_block (tree, tree, tree);

static tree patch_exit_expr (tree);

static tree build_labeled_block (int, tree);

static tree finish_labeled_statement (tree, tree);

static tree build_bc_statement (int, int, tree);

static tree patch_bc_statement (tree);

static tree patch_loop_statement (tree);

static tree build_new_loop (tree);

static tree build_loop_body (int, tree, int);

static tree finish_loop_body (int, tree, tree, int);

static tree build_debugable_stmt (int, tree);

static tree finish_for_loop (int, tree, tree, tree);

static tree patch_switch_statement (tree);

static tree string_constant_concatenation (tree, tree);

static tree build_string_concatenation (tree, tree);

static tree patch_string_cst (tree);

static tree patch_string (tree);

static tree encapsulate_with_try_catch (int, tree, tree, tree);

#ifdef USE_MAPPED_LOCATION

static tree build_assertion (source_location, tree, tree);

#else

static tree build_assertion (int, tree, tree);

#endif

static tree build_try_statement (int, tree, tree);

static tree build_try_finally_statement (int, tree, tree);

static tree patch_try_statement (tree);

static tree patch_synchronized_statement (tree, tree);

static tree patch_throw_statement (tree, tree);

static void add_exception_to_throws (tree, tree);

#ifdef USE_MAPPED_LOCATION

static void check_thrown_exceptions (source_location, tree, tree);

#else

static void check_thrown_exceptions (int, tree, tree);

#endif

static int check_thrown_exceptions_do (tree);

static bool ctors_unchecked_throws_clause_p (tree);

static void check_concrete_throws_clauses (tree, tree, tree, tree);

static void check_throws_clauses (tree, tree, tree);

static void finish_method_declaration (tree);

static tree build_super_invocation (tree);

static int verify_constructor_circularity (tree, tree);

static char *constructor_circularity_msg (tree, tree);

static tree build_this_super_qualified_invocation (int, tree, tree, int, int);

static const char *get_printable_method_name (tree);

static tree patch_conditional_expr (tree, tree, tree);

static tree generate_finit (tree);

static tree generate_instinit (tree);

static tree build_instinit_invocation (tree);

static void fix_constructors (tree);

static tree build_alias_initializer_parameter_list (int, tree, tree, int *);

static tree craft_constructor (tree, tree);

static tree get_constructor_super (tree);

static tree create_artificial_method (tree, int, tree, tree, tree);

static void start_artificial_method_body (tree);

static void end_artificial_method_body (tree);

static int check_method_redefinition (tree, tree);

static int check_method_types_complete (tree);

static bool hack_is_accessible_p (tree, tree);

static void java_check_regular_methods (tree);

static void check_interface_throws_clauses (tree, tree);

static void java_check_abstract_methods (tree);

static void unreachable_stmt_error (tree);

static int not_accessible_field_error (tree, tree);

static tree find_expr_with_wfl (tree);

static void missing_return_error (tree);

static tree build_new_array_init (int, tree);

static tree patch_new_array_init (tree, tree);

static tree maybe_build_array_element_wfl (tree);

static int array_constructor_check_entry (tree, constructor_elt *);

static const char *purify_type_name (const char *);

static tree fold_constant_for_init (tree, tree);

static jdeplist *reverse_jdep_list (struct parser_ctxt *);

static void static_ref_err (tree, tree, tree);

static void parser_add_interface (tree, tree, tree);

static void add_superinterfaces (tree, tree);

static tree jdep_resolve_class (jdep *);

static int note_possible_classname (const char *, int);

static void java_complete_expand_classes (void);

static void java_complete_expand_class (tree);

static void java_complete_expand_methods (tree);

static tree cut_identifier_in_qualified (tree);

static tree java_stabilize_reference (tree);

static tree do_unary_numeric_promotion (tree);

static char * operator_string (tree);

static tree do_merge_string_cste (tree, const char *, int, int);

static tree merge_string_cste (tree, tree, int);

static tree java_refold (tree);

static int java_decl_equiv (tree, tree);

static int binop_compound_p (enum tree_code);

static tree search_loop (tree);

static int labeled_block_contains_loop_p (tree, tree);

static int check_abstract_method_definitions (int, tree, tree);

static void java_check_abstract_method_definitions (tree);

static void java_debug_context_do (int);

static void java_parser_context_push_initialized_field (void);

static void java_parser_context_pop_initialized_field (void);

static tree reorder_static_initialized (tree);

static void java_parser_context_suspend (void);

static void java_parser_context_resume (void);

static int pop_current_osb (struct parser_ctxt *);

/* JDK 1.1 work. FIXME */

static tree maybe_make_nested_class_name (tree);

static int make_nested_class_name (tree);

static void link_nested_class_to_enclosing (void);

static tree resolve_inner_class (tree, tree, tree, tree);

static tree find_as_inner_class (tree, tree, tree);

static tree find_as_inner_class_do (tree, tree);

static int check_inner_class_redefinition (tree, tree);

static tree build_thisn_assign (void);

static tree build_current_thisn (tree);

static tree build_access_to_thisn (tree, tree, int);

static tree maybe_build_thisn_access_method (tree);

static tree build_nested_field_access (tree, tree);

static tree build_nested_field_access_methods (tree);

static tree build_nested_field_access_method (tree, tree, tree, tree, tree);

static tree build_nested_field_access_expr (int, tree, tree, tree, tree);

static tree build_nested_method_access_method (tree);

static tree build_new_access_id (void);

static int nested_member_access_p (tree, tree);

static int nested_field_expanded_access_p (tree, tree *, tree *, tree *);

static tree nested_field_access_fix (tree, tree, tree);

static tree build_incomplete_class_ref (int, tree);

static tree patch_incomplete_class_ref (tree);

static tree create_anonymous_class (tree);

static void patch_anonymous_class (tree, tree, tree);

static void add_inner_class_fields (tree, tree);

static tree build_dot_class_method (tree);

static tree build_dot_class_method_invocation (tree, tree);

static void create_new_parser_context (int);

static tree maybe_build_class_init_for_field (tree, tree);

static int emit_test_initialization (void **, void *);

static char *string_convert_int_cst (tree);

/* Number of error found so far. */

int java_error_count;

/* Number of warning found so far. */

int java_warning_count;

/* Cyclic inheritance report, as it can be set by layout_class */

const char *cyclic_inheritance_report;

/* The current parser context */

struct parser_ctxt *ctxp;

/* List of things that were analyzed for which code will be generated */

struct parser_ctxt *ctxp_for_generation = NULL;

struct parser_ctxt *ctxp_for_generation_last = NULL;

/* binop_lookup maps token to tree_code. It is used where binary

   operations are involved and required by the parser. RDIV_EXPR

   covers both integral/floating point division. The code is changed

   once the type of both operator is worked out.  */

static const enum tree_code binop_lookup[19] =

  {

    PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,

    LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,

    BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,

    TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,

    EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,

   };

#define BINOP_LOOKUP(VALUE)                                             \

  binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]

/* This is the end index for binary operators that can also be used

   in compound assignments. */

#define BINOP_COMPOUND_CANDIDATES 11

/* The "$L" identifier we use to create labels.  */

static GTY(()) tree label_id;

/* The "StringBuffer" identifier used for the String `+' operator. */

static GTY(()) tree wfl_string_buffer;

/* The "append" identifier used for String `+' operator.  */

static GTY(()) tree wfl_append;

/* The "toString" identifier used for String `+' operator. */

static GTY(()) tree wfl_to_string;

/* The "java.lang" import qualified name.  */

static GTY(()) tree java_lang_id;

/* The generated `inst$' identifier used for generated enclosing

   instance/field access functions.  */

static GTY(()) tree inst_id;

/* Context and flag for static blocks */

static GTY(()) tree current_static_block;

/* The generated `write_parm_value$' identifier.  */

static GTY(()) tree wpv_id;

/* Hold THIS for the scope of the current method decl.  */

static GTY(()) tree current_this;

/* Hold a list of catch clauses list. The first element of this list is

   the list of the catch clauses of the currently analyzed try block. */

static GTY(()) tree currently_caught_type_list;

/* This holds a linked list of all the case labels for the current

   switch statement.  It is only used when checking to see if there

   are duplicate labels.  FIXME: probably this should just be attached

   to the switch itself; then it could be referenced via

   `ctxp->current_loop'.  */

static GTY(()) tree case_label_list;

/* Anonymous class counter. Will be reset to 1 every time a non

   anonymous class gets created. */

static int anonymous_class_counter = 1;

static GTY(()) tree src_parse_roots[1];

/* All classes seen from source code */

#define gclass_list src_parse_roots[0]

/* Check modifiers. If one doesn't fit, retrieve it in its declaration

   line and point it out.  */

/* Should point out the one that don't fit. ASCII/unicode, going

   backward. FIXME */

#define check_modifiers(__message, __value, __mask) do {        \

  if ((__value) & ~(__mask))                                    \

    {                                                           \

      size_t i, remainder = (__value) & ~(__mask);         \

      for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++) \

        if ((1 << i) & remainder)                               \

          parse_error_context (ctxp->modifier_ctx [i], (__message), \

                               java_accstring_lookup (1 << i)); \

    }                                                           \

} while (0)

%}

%union {

  tree node;

  int sub_token;

  struct {

    int token;

#ifdef USE_MAPPED_LOCATION

    source_location location;

#else

    int location;

#endif

  } operator;

  int value;

}

%{

#ifdef USE_MAPPED_LOCATION

#define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \

  SET_EXPR_LOCATION(EXPR, (TOKEN).location)

#else

#define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \

  (EXPR_WFL_LINECOL (EXPR) = (TOKEN).location)

#endif

#include "lex.c"

%}

%pure_parser

/* Things defined here have to match the order of what's in the

   binop_lookup table.  */

%token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK

%token   LS_TK           SRS_TK          ZRS_TK

%token   AND_TK          XOR_TK          OR_TK

%token   BOOL_AND_TK BOOL_OR_TK

%token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK

/* This maps to the same binop_lookup entry than the token above */

%token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK

%token   REM_ASSIGN_TK

%token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK

%token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK

/* Modifier TOKEN have to be kept in this order. Don't scramble it */

%token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK

%token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK

%token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK

%token   PAD_TK          ABSTRACT_TK        STRICT_TK

%token   MODIFIER_TK

/* Keep those two in order, too */

%token   DECR_TK INCR_TK

/* From now one, things can be in any order */

%token   DEFAULT_TK      IF_TK              THROW_TK

%token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK

%token   THROWS_TK       BREAK_TK           IMPORT_TK

%token   ELSE_TK         INSTANCEOF_TK      RETURN_TK

%token   VOID_TK         CATCH_TK           INTERFACE_TK

%token   CASE_TK         EXTENDS_TK         FINALLY_TK

%token   SUPER_TK        WHILE_TK           CLASS_TK

%token   SWITCH_TK       CONST_TK           TRY_TK

%token   FOR_TK          NEW_TK             CONTINUE_TK

%token   GOTO_TK         PACKAGE_TK         THIS_TK

%token   ASSERT_TK

%token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK

%token   CHAR_TK         INTEGRAL_TK

%token   FLOAT_TK        DOUBLE_TK          FP_TK

%token   ID_TK

%token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK

%token   ASSIGN_ANY_TK   ASSIGN_TK

%token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK

%token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK

%token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK

%type           modifiers MODIFIER_TK final synchronized

%type                   super ID_TK identifier

%type                   name simple_name qualified_name

%type                   type_declaration compilation_unit

                        field_declaration method_declaration extends_interfaces

                        interfaces interface_type_list

                        import_declarations package_declaration

                        type_declarations interface_body

                        interface_member_declaration constant_declaration

                        interface_member_declarations interface_type

                        abstract_method_declaration

%type                   class_body_declaration class_member_declaration

                        static_initializer constructor_declaration block

%type                   class_body_declarations constructor_header

%type                   class_or_interface_type class_type class_type_list

                        constructor_declarator explicit_constructor_invocation

%type             dim_expr dim_exprs this_or_super throws

%type                   variable_declarator_id variable_declarator

                        variable_declarators variable_initializer

                        variable_initializers constructor_body

                        array_initializer

%type                   class_body block_end constructor_block_end

%type                   statement statement_without_trailing_substatement

                        labeled_statement if_then_statement label_decl

                        if_then_else_statement while_statement for_statement

                        statement_nsi labeled_statement_nsi do_statement

                        if_then_else_statement_nsi while_statement_nsi

                        for_statement_nsi statement_expression_list for_init

                        for_update statement_expression expression_statement

                        primary_no_new_array expression primary array_type

                        array_creation_initialized array_creation_uninitialized

                        class_instance_creation_expression field_access

                        method_invocation array_access something_dot_new

                        argument_list postfix_expression while_expression

                        post_increment_expression post_decrement_expression

                        unary_expression_not_plus_minus unary_expression

                        pre_increment_expression pre_decrement_expression

                        cast_expression

                        multiplicative_expression additive_expression

                        shift_expression relational_expression

                        equality_expression and_expression

                        exclusive_or_expression inclusive_or_expression

                        conditional_and_expression conditional_or_expression

                        conditional_expression assignment_expression

                        left_hand_side assignment for_header for_begin

                        constant_expression do_statement_begin empty_statement

                        switch_statement synchronized_statement throw_statement

                        try_statement assert_statement

                        switch_expression switch_block

                        catches catch_clause catch_clause_parameter finally

                        anonymous_class_creation trap_overflow_corner_case

%type             return_statement break_statement continue_statement

%type         ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK

%type         REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK

%type         LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK

%type         AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK

%type         ASSIGN_ANY_TK  assignment_operator

%token        EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK

%token        BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK

%token        DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK

%token        NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK

%token        OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK

%type           THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK

%type         CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK

%type         NEW_TK ASSERT_TK

%type                   method_body

%type                   literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK

                        STRING_LIT_TK NULL_TK VOID_TK

%type                   IF_TK WHILE_TK FOR_TK

%type             formal_parameter_list formal_parameter

                        method_declarator method_header

%type                   primitive_type reference_type type

                        BOOLEAN_TK INTEGRAL_TK FP_TK

/* Added or modified JDK 1.1 rule types  */

%type                   type_literals

%%

/* 19.2 Production from 2.3: The Syntactic Grammar  */

goal:  compilation_unit

                {}

;

/* 19.3 Productions from 3: Lexical structure  */

literal:

        INT_LIT_TK

|       FP_LIT_TK

|       BOOL_LIT_TK

|       CHAR_LIT_TK

|       STRING_LIT_TK

|       NULL_TK

;

/* 19.4 Productions from 4: Types, Values and Variables  */

type:

        primitive_type

|       reference_type

;

primitive_type:

        INTEGRAL_TK

|       FP_TK

|       BOOLEAN_TK

;

reference_type:

        class_or_interface_type

|       array_type

;

class_or_interface_type:

        name

;

class_type:

        class_or_interface_type /* Default rule */

;

interface_type:

         class_or_interface_type

;

array_type:

        primitive_type dims

                {

                  int osb = pop_current_osb (ctxp);

                  tree t = build_java_array_type (($1), -1);

                  while (--osb)

                    t = build_unresolved_array_type (t);

                  $$ = t;

                }

|       name dims

                {

                  int osb = pop_current_osb (ctxp);

                  tree t = $1;

                  while (osb--)

                    t = build_unresolved_array_type (t);

                  $$ = t;

                }

;

/* 19.5 Productions from 6: Names  */

name:

        simple_name             /* Default rule */

|       qualified_name          /* Default rule */

;

simple_name:

        identifier              /* Default rule */

;

qualified_name:

        name DOT_TK identifier

                { $$ = make_qualified_name ($1, $3, $2.location); }

;

identifier:

        ID_TK

;

/* 19.6: Production from 7: Packages  */

compilation_unit:

                {$$ = NULL;}

|       package_declaration

|       import_declarations

|       type_declarations

|       package_declaration import_declarations

|       package_declaration type_declarations

|       import_declarations type_declarations

|       package_declaration import_declarations type_declarations

;

import_declarations:

        import_declaration

                {

                  $$ = NULL;

                }

|       import_declarations import_declaration

                {

                  $$ = NULL;

                }

;

type_declarations:

        type_declaration

|       type_declarations type_declaration

;

package_declaration:

        PACKAGE_TK name SC_TK

                {

                  ctxp->package = EXPR_WFL_NODE ($2);

                }

|       PACKAGE_TK error

                {yyerror ("Missing name"); RECOVER;}

|       PACKAGE_TK name error

                {yyerror ("';' expected"); RECOVER;}

;

import_declaration:

        single_type_import_declaration

|       type_import_on_demand_declaration

;

single_type_import_declaration:

        IMPORT_TK name SC_TK

                {

                  tree name = EXPR_WFL_NODE ($2), last_name;

                  int   i = IDENTIFIER_LENGTH (name)-1;

                  const char *last = &IDENTIFIER_POINTER (name)[i];

                  while (last != IDENTIFIER_POINTER (name))

                    {

                      if (last [0] == '.')

                        break;

                      last--;

                    }

                  last_name = get_identifier (++last);

                  if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))

                    {

                      tree err = find_name_in_single_imports (last_name);

                      if (err && err != name)

                        parse_error_context

                          ($2, "Ambiguous class: %qs and %qs",

                           IDENTIFIER_POINTER (name),

                           IDENTIFIER_POINTER (err));

                      else

                        REGISTER_IMPORT ($2, last_name);

                    }

                  else

                    REGISTER_IMPORT ($2, last_name);

                }

|       IMPORT_TK error

                {yyerror ("Missing name"); RECOVER;}

|       IMPORT_TK name error

                {yyerror ("';' expected"); RECOVER;}

;

type_import_on_demand_declaration:

        IMPORT_TK name DOT_TK MULT_TK SC_TK

                {

                  tree name = EXPR_WFL_NODE ($2);

                  tree it;

                  /* Search for duplicates. */

                  for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))

                    if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)

                      break;

                  /* Don't import the same thing more than once, just ignore

                     duplicates (7.5.2) */

                  if (! it)

                    {

                      read_import_dir ($2);

                      ctxp->import_demand_list =

                        chainon (ctxp->import_demand_list,

                                 build_tree_list ($2, NULL_TREE));

                    }

                }

|       IMPORT_TK name DOT_TK error

                {yyerror ("'*' expected"); RECOVER;}

|       IMPORT_TK name DOT_TK MULT_TK error

                {yyerror ("';' expected"); RECOVER;}

;

type_declaration:

        class_declaration

                { end_class_declaration (0); }

|       interface_declaration

                { end_class_declaration (0); }

|       empty_statement

|       error

                {

                  YYERROR_NOW;

                  yyerror ("Class or interface declaration expected");

                }

;

/* 19.7 Shortened from the original:

   modifiers: modifier | modifiers modifier

   modifier: any of public...  */

modifiers:

        MODIFIER_TK

                {

                  $$ = (1 << $1);

                }

|       modifiers MODIFIER_TK

                {

                  int acc = (1 << $2);

                  if ($$ & acc)

                    parse_error_context

                      (ctxp->modifier_ctx [$2], "Modifier %qs declared twice",

                       java_accstring_lookup (acc));

                  else

                    {

                      $$ |= acc;

                    }

                }

;

/* 19.8.1 Production from $8.1: Class Declaration */

class_declaration:

        modifiers CLASS_TK identifier super interfaces

                { create_class ($1, $3, $4, $5); }

        class_body

                {;}

|       CLASS_TK identifier super interfaces

                { create_class (0, $2, $3, $4); }

        class_body

                {;}

|       modifiers CLASS_TK error

                { yyerror ("Missing class name"); RECOVER; }

|       CLASS_TK error

                { yyerror ("Missing class name"); RECOVER; }

|       CLASS_TK identifier error

                {

                  if (!ctxp->class_err) yyerror ("'{' expected");

                  DRECOVER(class1);

                }

|       modifiers CLASS_TK identifier error

                { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }

;

super:

                { $$ = NULL; }

|       EXTENDS_TK class_type

                { $$ = $2; }

|       EXTENDS_TK class_type error

                {yyerror ("'{' expected"); ctxp->class_err=1;}

|       EXTENDS_TK error

                {yyerror ("Missing super class name"); ctxp->class_err=1;}

;

interfaces:

                { $$ = NULL_TREE; }

|       IMPLEMENTS_TK interface_type_list

                { $$ = $2; }

|       IMPLEMENTS_TK error

                {

                  ctxp->class_err=1;

                  yyerror ("Missing interface name");

                }

;

interface_type_list:

        interface_type

                {

                  ctxp->interface_number = 1;

                  $$ = build_tree_list ($1, NULL_TREE);

                }

|       interface_type_list C_TK interface_type

                {

                  ctxp->interface_number++;

                  $$ = chainon ($1, build_tree_list ($3, NULL_TREE));

                }

|       interface_type_list C_TK error

                {yyerror ("Missing interface name"); RECOVER;}

;

class_body:

        OCB_TK CCB_TK

                {

                  $$ = GET_CPC ();

                }

|       OCB_TK class_body_declarations CCB_TK

                {

                  $$ = GET_CPC ();

                }

;

class_body_declarations:

        class_body_declaration

|       class_body_declarations class_body_declaration

;

class_body_declaration:

        class_member_declaration

|       static_initializer

|       constructor_declaration

|       block                   /* Added, JDK1.1, instance initializer */

                {

                  if (!IS_EMPTY_STMT ($1))

                    {

                      TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);

                      SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);

                    }

                }

;

class_member_declaration:

        field_declaration

|       method_declaration

|       class_declaration       /* Added, JDK1.1 inner classes */

                { end_class_declaration (1); }