/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2008 Sun Microsystems, Inc.

 */

package org.netbeans.modules.ada.editor.parser;

import org.netbeans.modules.ada.editor.lexer.Ada95ASTLexer;

parser code {:

    private ErrorStrategy defaultStrategy = new DefaultErrorStrategy();;

    private ErrorStrategy errorStrategy = defaultStrategy;

    private ParserErrorHandler errorHandler = null;

    public void setErrorHandler (ParserErrorHandler handler) {

        this.errorHandler = handler;

    }

    public ParserErrorHandler getErrorHandler () {

        return this.errorHandler;

    }

    interface ErrorStrategy {

        public boolean errorRecovery(boolean debug) throws Exception;

    }

    class DefaultErrorStrategy implements ErrorStrategy {

        public boolean errorRecovery(boolean debug) throws Exception {

            return Ada95ASTParser.super.error_recovery(debug);

        }

    }

    /**

     * Attempt to recover from a syntax error.  This returns false if recovery fails,

     * true if it succeeds.

     * @param debug should we produce debugging messages as we parse.

     */

    @Override

    protected boolean error_recovery(boolean debug) throws java.lang.Exception {

        return errorStrategy.errorRecovery(debug);

    }

    /**

     * Report a non fatal error (or warning).  This method takes a message

     * string and an additional object (to be used by specializations implemented in subclasses).

     * The super class prints the message to System.err.

     * @param message an error message.

     * @param info    an extra object reserved for use by specialized subclasses.

     */

    @Override

    public void report_error(String message, Object info) {

        System.out.print("report_eror"  + message);

    }	

    /**

     * This method is called when a syntax error has been detected and recovery is about to be invoked.

     * The super class just emit a "Syntax error" error message.

     * @param cur_token the current lookahead Symbol.

     */

    @Override

    public void syntax_error(java_cup.runtime.Symbol cur_token) {

        java_cup.runtime.Symbol symbol = (java_cup.runtime.Symbol)stack.peek();

        int state = symbol.parse_state;

        short[] rowOfProbe = action_tab[state];

        if (errorHandler != null) {

            errorHandler.handleError(ParserErrorHandler.Type.SYNTAX_ERROR, rowOfProbe, cur_token, symbol);

        }

     }

    /**

     * This method is called when a syntax error has been detected during action.

     * @param message an error message.

     */

    public void message_error(String message) {

        java_cup.runtime.Symbol symbol = (java_cup.runtime.Symbol)stack.peek();

        if (errorHandler != null) {

            errorHandler.handleError(ParserErrorHandler.Type.SYNTAX_ERROR, symbol, message);

        }

     }

     /**

     * Report a fatal error.  This method takes a message string and an additional object

     * (to be used by specializations implemented in subclasses).

     * The super class reports the error then throws an exception.

     * @param message an error message.

     * @param info    an extra object reserved for use by specialized subclasses.

     */

    @Override

    public void report_fatal_error(String message, Object info) throws Exception {

        if (errorHandler != null) {

            errorHandler.handleError(ParserErrorHandler.Type.FATAL_PARSER_ERROR, null, cur_token, null);

        }

    }

    @Override

    protected int error_sync_size() {

        return 1;

    }

:}

/*********************************************************

 *                                                       *

 * Ada 95 (LALR) Parser (no AST), based on:              *

 *                                                       *

 * 1. Ada Reference Manual                               *

 *    ISO/IEC 8652:1995(E)                               *

 *    with Technical Corrigendum 1                       *

 *    Language and Standard Libraries                    *

 *    Copyright © 1992,1993,1994,1995 Intermetrics, Inc. *

 *    Copyright © 2000 The MITRE Corporation, Inc.       *

 * 2. http://www.adaic.com/standards/95lrm/grammar9x.y   *

 *                                                       *

 * Author: Andrea Lucarelli                              *

 * Parser Generator: JavCup                              *

 *                                                       *

 *********************************************************/

/*************************

 * JavaCup Terminals     *

 *************************/

//

// Ada 95 keywords

//

terminal ABORT;

terminal ABS;

terminal ABSTRACT;

terminal ACCEPT;

terminal ACCESS;

terminal ALIASED;

terminal ALL;

terminal AND;

terminal ARRAY;

terminal AT;

terminal BEGIN;

terminal BODY;

terminal CASE;

terminal CONSTANT;

terminal DECLARE;

terminal DELAY;

terminal DELTA;

terminal DIGITS;

terminal DO;

terminal ELSE;

terminal ELSIF;

terminal END;

terminal ENTRY;

terminal EXCEPTION;

terminal EXIT;

terminal FOR;

terminal FUNCTION;

terminal GENERIC;

terminal GOTO;

terminal IF;

terminal IN;

terminal IS;

terminal LIMITED;

terminal LOOP;

terminal MOD;

terminal NEW;

terminal NOT;

terminal NULL;

terminal OF;

terminal OR;

terminal OTHERS;

terminal OUT;

terminal PACKAGE;

terminal PRAGMA;

terminal PRIVATE;

terminal PROCEDURE;

terminal PROTECTED;

terminal RAISE;

terminal RANGE;

terminal RECORD;

terminal REM;

terminal RENAMES;

terminal REQUEUE;

terminal RETURN;

terminal REVERSE;

terminal SELECT;

terminal SEPARATE;

terminal SUBTYPE;

terminal TAGGED;

terminal TASK;

terminal TERMINATE;

terminal THEN;

terminal TYPE;

terminal UNTIL;

terminal USE;

terminal WHEN;

terminal WHILE;

terminal WITH;

terminal XOR;

//

// delimiters

//

terminal AMP;

terminal TICK;

terminal LPAREN;

terminal RPAREN;

terminal STAR;

terminal PLUS;

terminal COMMA;

terminal MINUS;

terminal DOT;

terminal SLASH;

terminal COLON;

terminal SEMICOLON;

terminal GT;

terminal EQ;

terminal LT;

terminal BAR;

//

// compound delimiters

//

terminal ARROW;

terminal DOT_DOT;

terminal EXPON;

terminal ASSIGNMENT;

terminal INEQ;

terminal GTEQ;

terminal LTEQ;

terminal LTLT;

terminal GTGT;

terminal BOX;

terminal BASED_LITERAL;

terminal DECIMAL_LITERAL;

terminal CHAR_LITERAL;

terminal STRING_LITERAL;

terminal IDENTIFIER;

non terminal compilation;

non terminal pragma;

non terminal simple_name;

non terminal pragma_arg_s;

non terminal pragma_arg;

non terminal pragma_s;

non terminal decl;

non terminal object_decl;

non terminal def_id_s;

non terminal def_id;

non terminal object_qualifier_opt;

non terminal object_subtype_def;

non terminal init_opt;

non terminal number_decl;

non terminal type_decl;

non terminal discrim_part_opt;

non terminal type_completion;

non terminal type_def;

non terminal subtype_decl;

non terminal subtype_ind;

non terminal constraint;

non terminal decimal_digits_constraint;

non terminal derived_type;

non terminal range_constraint;

non terminal range;

non terminal enumeration_type;

non terminal enum_id_s;

non terminal enum_id;

non terminal integer_type;

non terminal range_spec;

non terminal range_spec_opt;

non terminal real_type;

non terminal float_type;

non terminal fixed_type;

non terminal array_type;

non terminal unconstr_array_type;

non terminal constr_array_type;

non terminal component_subtype_def;

non terminal aliased_opt;

non terminal index_s;

non terminal index;

non terminal iter_index_constraint;

non terminal iter_discrete_range_s;

non terminal discrete_range;

non terminal range_constr_opt;

non terminal record_type;

non terminal record_def;

non terminal tagged_opt;

non terminal comp_list;

non terminal comp_decl_s;

non terminal variant_part_opt;

non terminal comp_decl;

non terminal discrim_part;

non terminal discrim_spec_s;

non terminal discrim_spec;

non terminal access_opt;

non terminal variant_part;

non terminal variant_s;

non terminal variant;

non terminal choice_s;

non terminal choice;

non terminal discrete_with_range;

non terminal access_type;

non terminal prot_opt;

non terminal decl_part;

non terminal decl_item_s;

non terminal decl_item_s1;

non terminal decl_item;

non terminal decl_item_or_body_s1;

non terminal decl_item_or_body;

non terminal body;

non terminal name;

non terminal mark;

non terminal compound_name;

non terminal c_name_list;

non terminal used_char;

non terminal operator_symbol;

non terminal indexed_comp;

non terminal value_s;

non terminal value;

non terminal selected_comp;

non terminal attribute;

non terminal attribute_id;

non terminal literal;

non terminal aggregate;

non terminal value_s_2;

non terminal comp_assoc;

non terminal expression;

non terminal logical;

non terminal short_circuit;

non terminal relation;

non terminal relational;

non terminal membership;

non terminal simple_expression;

non terminal unary;

non terminal adding;

non terminal term;

non terminal multiplying;

non terminal factor;

non terminal primary;

non terminal parenthesized_primary;

non terminal qualified;

non terminal allocator;

non terminal statement_s;

non terminal statement;

non terminal unlabeled;

non terminal simple_stmt;

non terminal compound_stmt;

non terminal label;

non terminal NULL_stmt;

non terminal assign_stmt;

non terminal if_stmt;

non terminal cond_clause_s;

non terminal cond_clause;

non terminal cond_part;

non terminal condition;

non terminal else_opt;

non terminal case_stmt;

non terminal case_hdr;

non terminal alternative_s;

non terminal alternative;

non terminal loop_stmt;

non terminal label_opt;

non terminal iteration;

non terminal iter_part;

non terminal reverse_opt;

non terminal basic_loop;

non terminal id_opt;

non terminal block;

non terminal block_decl;

non terminal block_body;

non terminal handled_stmt_s;

non terminal except_handler_part_opt;

non terminal exit_stmt;

non terminal name_opt;

non terminal when_opt;

non terminal return_stmt;

non terminal goto_stmt;

non terminal subprog_decl;

non terminal subprog_spec;

non terminal designator;

non terminal formal_part_opt;

non terminal formal_part;

non terminal param_s;

non terminal param;

non terminal mode;

non terminal subprog_spec_is_push;

non terminal subprog_body;

non terminal procedure_call;

non terminal pkg_decl;

non terminal pkg_spec;

non terminal private_part;

non terminal c_id_opt;

non terminal pkg_body;

non terminal body_opt;

non terminal private_type;

non terminal limited_opt;

non terminal use_clause;

non terminal name_s;

non terminal rename_decl;

non terminal rename_unit;

non terminal renames;

non terminal task_decl;

non terminal task_spec;

non terminal task_def;

non terminal task_private_opt;

non terminal task_body;

non terminal prot_decl;

non terminal prot_spec;

non terminal prot_def;

non terminal prot_private_opt;

non terminal prot_op_decl_s;

non terminal prot_op_decl;

non terminal prot_elem_decl_s;

non terminal prot_elem_decl;

non terminal prot_body;

non terminal prot_op_body_s;

non terminal prot_op_body;

non terminal entry_decl_s;

non terminal entry_decl;

non terminal entry_body;

non terminal entry_body_part;

non terminal rep_spec_s;

non terminal entry_call;

non terminal accept_stmt;

non terminal accept_hdr;

non terminal entry_name;

non terminal delay_stmt;

non terminal select_stmt;

non terminal select_wait;

non terminal guarded_select_alt;

non terminal or_select;

non terminal select_alt;

non terminal delay_or_entry_alt;

non terminal async_select;

non terminal timed_entry_call;

non terminal cond_entry_call;

non terminal stmts_opt;

non terminal abort_stmt;

non terminal comp_unit;

non terminal private_opt;

non terminal context_spec;

non terminal with_clause;

non terminal use_clause_opt;

non terminal unit;

non terminal subunit;

non terminal subunit_body;

non terminal body_stub;

non terminal exception_decl;

non terminal except_handler_part;

non terminal exception_handler;

non terminal except_choice_s;

non terminal except_choice;

non terminal raise_stmt;

non terminal requeue_stmt;

non terminal generic_decl;

non terminal generic_formal_part;

non terminal generic_formal;

non terminal generic_discrim_part_opt;

non terminal subp_default;

non terminal generic_type_def;

non terminal generic_derived_type;

non terminal generic_subp_inst;

non terminal generic_pkg_inst;

non terminal generic_inst;

non terminal rep_spec;

non terminal attrib_def;

non terminal record_type_spec;

non terminal align_opt;

non terminal comp_loc_s;

non terminal address_spec;

non terminal code_stmt;

// root symbol 

start with compilation;

pragma  ::= PRAGMA IDENTIFIER SEMICOLON

	| PRAGMA simple_name LPAREN pragma_arg_s RPAREN SEMICOLON

	;

pragma_arg_s ::= pragma_arg

	| pragma_arg_s COMMA pragma_arg

	;

pragma_arg ::= expression

	| simple_name ARROW expression

	;

pragma_s ::=

	| pragma_s pragma

	;

decl    ::= object_decl

	| number_decl

	| type_decl

	| subtype_decl

	| subprog_decl

	| pkg_decl

	| task_decl

	| prot_decl

	| exception_decl

	| rename_decl

	| generic_decl

	| body_stub

	| error SEMICOLON

	;

object_decl ::= def_id_s COLON object_qualifier_opt object_subtype_def init_opt SEMICOLON

	;

def_id_s ::= def_id

	| def_id_s COMMA def_id

	;

def_id  ::= IDENTIFIER

	;

object_qualifier_opt ::=

	| ALIASED

	| CONSTANT

	| ALIASED CONSTANT

	;

object_subtype_def ::= subtype_ind

	| array_type

	;

init_opt ::=

	| ASSIGNMENT expression

	;

number_decl ::= def_id_s COLON CONSTANT ASSIGNMENT expression SEMICOLON

	;

type_decl ::= TYPE IDENTIFIER discrim_part_opt type_completion SEMICOLON

	;

discrim_part_opt ::=

	| discrim_part

	| LPAREN BOX RPAREN

	;

type_completion ::=

	| IS type_def

	;

type_def ::= enumeration_type

	| integer_type

	| real_type

	| array_type

	| record_type

	| access_type

	| derived_type

	| private_type

	;

subtype_decl ::= SUBTYPE IDENTIFIER IS subtype_ind SEMICOLON

	;

subtype_ind ::= name constraint

	| name

	;

constraint ::= range_constraint

	| decimal_digits_constraint

	;

decimal_digits_constraint ::= DIGITS expression range_constr_opt

	;

derived_type ::= NEW subtype_ind

	| NEW subtype_ind WITH PRIVATE

	| NEW subtype_ind WITH record_def

	| ABSTRACT NEW subtype_ind WITH PRIVATE

	| ABSTRACT NEW subtype_ind WITH record_def

	;

range_constraint ::= RANGE range

	;

range ::= simple_expression DOT_DOT simple_expression

	| name TICK RANGE

	| name TICK RANGE LPAREN expression RPAREN

	;

enumeration_type ::= LPAREN enum_id_s RPAREN

;

enum_id_s ::= enum_id

	| enum_id_s COMMA enum_id

	;

enum_id ::= IDENTIFIER

	| CHAR_LITERAL

	;

integer_type ::= range_spec

	| MOD expression

	;

range_spec ::= range_constraint

	;

range_spec_opt ::=

	| range_spec

	;

real_type ::= float_type

	| fixed_type

	;

float_type ::= DIGITS expression range_spec_opt

	;

fixed_type ::= DELTA expression range_spec

	| DELTA expression DIGITS expression range_spec_opt

	;

array_type ::= unconstr_array_type

	| constr_array_type

	;

unconstr_array_type ::= ARRAY LPAREN index_s RPAREN OF component_subtype_def

	;

constr_array_type ::= ARRAY iter_index_constraint OF component_subtype_def

	;

component_subtype_def ::= aliased_opt subtype_ind

	;

aliased_opt ::=

	| ALIASED

	;

index_s ::= index

	| index_s COMMA index

	;

index ::= name RANGE BOX

	;

iter_index_constraint ::= LPAREN iter_discrete_range_s RPAREN

	;

iter_discrete_range_s ::= discrete_range

	| iter_discrete_range_s COMMA discrete_range

	;

discrete_range ::= name range_constr_opt

	| range

	;

range_constr_opt ::=

	| range_constraint

	;

record_type ::= tagged_opt limited_opt record_def

	;

record_def ::= RECORD pragma_s comp_list END RECORD

	| NULL RECORD

	;

tagged_opt ::=

	| TAGGED

	| ABSTRACT TAGGED

	;

comp_list ::= comp_decl_s variant_part_opt

	| variant_part pragma_s

	| NULL SEMICOLON pragma_s

	;

comp_decl_s ::= comp_decl

	| comp_decl_s pragma_s comp_decl

	;

variant_part_opt ::= pragma_s

	| pragma_s variant_part pragma_s

	;

comp_decl ::= def_id_s COLON component_subtype_def init_opt SEMICOLON

	| error SEMICOLON

	;

discrim_part ::= LPAREN discrim_spec_s RPAREN

	;

discrim_spec_s ::= discrim_spec

	| discrim_spec_s SEMICOLON discrim_spec

	;

discrim_spec ::= def_id_s COLON access_opt mark init_opt

	| error

	;

access_opt ::=

	| ACCESS

	;

variant_part ::= CASE simple_name IS pragma_s variant_s END CASE SEMICOLON

	;

variant_s ::= variant

	| variant_s variant

	;

variant ::= WHEN choice_s ARROW pragma_s comp_list

	;

choice_s ::= choice

	| choice_s BAR choice

	;

choice ::= expression

	| discrete_with_range

	| OTHERS

	;

discrete_with_range ::= name range_constraint

	| range

	;

access_type ::= ACCESS subtype_ind

	| ACCESS CONSTANT subtype_ind

	| ACCESS ALL subtype_ind

	| ACCESS prot_opt PROCEDURE formal_part_opt

	| ACCESS prot_opt FUNCTION formal_part_opt RETURN mark

	;

prot_opt ::=

	| PROTECTED

	;

decl_part ::=

	| decl_item_or_body_s1

	;

decl_item_s ::=

	| decl_item_s1

	;

decl_item_s1 ::= decl_item

	| decl_item_s1 decl_item

	;

decl_item ::= decl

	| use_clause

	| rep_spec

	| pragma

	;

decl_item_or_body_s1 ::= decl_item_or_body

	| decl_item_or_body_s1 decl_item_or_body

	;

decl_item_or_body ::= body

	| decl_item

	;

body ::= subprog_body

	| pkg_body

	| task_body

	| prot_body

	;

name ::= simple_name

	| indexed_comp

	| selected_comp

	| attribute

	| operator_symbol

	;

mark ::= simple_name

	| mark TICK attribute_id

	| mark DOT simple_name

	;

simple_name ::=

IDENTIFIER:identifier

{:

    RESULT = identifier;

:}

;

compound_name ::=

simple_name:simpleName

{:

    RESULT = simpleName;

:}

| compound_name:compoundName DOT simple_name:simpleName

{:

    RESULT = compoundName + "." + simpleName;

:}

;

c_name_list ::= compound_name

	 | c_name_list COMMA compound_name

	;

used_char ::= CHAR_LITERAL

	;

operator_symbol ::= STRING_LITERAL

	;

indexed_comp ::= name LPAREN value_s RPAREN

	;

value_s ::= value

	| value_s COMMA value

	;

value ::= expression

	| comp_assoc

	| discrete_with_range

	| error

	;

selected_comp ::= name DOT simple_name

	| name DOT used_char

	| name DOT operator_symbol

	| name DOT ALL

	;

attribute ::= name TICK attribute_id

	;

attribute_id ::= IDENTIFIER

	| DIGITS

	| DELTA

	| ACCESS

	;

literal ::= DECIMAL_LITERAL

    | BASED_LITERAL

	| used_char

	| NULL

	;

aggregate ::= LPAREN comp_assoc RPAREN

	| LPAREN value_s_2 RPAREN

	| LPAREN expression WITH value_s RPAREN

	| LPAREN expression WITH NULL RECORD RPAREN

	| LPAREN NULL RECORD RPAREN

	;

value_s_2 ::= value COMMA value

	| value_s_2 COMMA value

	;

comp_assoc ::= choice_s ARROW expression

	;

expression ::= relation

	| expression logical relation

	| expression short_circuit relation

	;

logical ::= AND

	| OR

	| XOR

	;

short_circuit ::= AND THEN

	| OR ELSE

	;

relation ::= simple_expression

	| simple_expression relational simple_expression

	| simple_expression membership range

	| simple_expression membership name

	;

relational ::= EQ

	| INEQ

	| GT

	| LTEQ

	| LT

	| GTEQ

	;

membership ::= IN

	| NOT IN

	;

simple_expression ::= unary term

	| term

	| simple_expression adding term

	;

unary   ::= PLUS

	| MINUS

	;

adding  ::= PLUS

	| MINUS

	| AMP

	;

term    ::= factor

	| term multiplying factor

	;

multiplying ::= STAR

	| SLASH

	| MOD

	| REM

	;

factor ::= primary

	| NOT primary

	| ABS primary

	| primary EXPON primary

	;

primary ::= literal

	| name

	| allocator

	| qualified

	| parenthesized_primary

	;

parenthesized_primary ::= aggregate

	| LPAREN expression RPAREN

	;

qualified ::= name TICK parenthesized_primary

	;

allocator ::= NEW name

	| NEW qualified

	;

statement_s ::= statement

	| statement_s statement

	;

statement ::= unlabeled

	| label statement

	;

unlabeled ::= simple_stmt

	| compound_stmt

	| pragma

	;

simple_stmt ::= NULL_stmt

	| assign_stmt

	| exit_stmt

	| return_stmt

	| goto_stmt

	| procedure_call

	| delay_stmt

	| abort_stmt

	| raise_stmt

	| code_stmt

	| requeue_stmt

	| error SEMICOLON