Subversion Repositories tendra.SVN

%prefixes%

/*

    TERMINAL PREFIX

    This prefix is used to identify lexical token numbers in syntax.h

    (see also symbols.h).

*/

terminal = lex_ ;

%maps%

/*

    PARSER ENTRY POINTS

    There are a number of entry points into the parser.  The main ones

    are translation-unit which is used to parse an entire translation

    unit and hash-if-expression which is used to parse expressions in

    #if preprocessing directives.

*/

translation-unit -> parse_file ;

expression-entry -> parse_exp ;

id-entry -> parse_id ;

operator-id -> parse_operator ;

declaration-entry -> parse_decl ;

function-definition-entry -> parse_func ;

type-id-entry -> parse_type ;

token-type-id -> parse_tok_type ;

member-type-id -> parse_mem_type ;

parameter-entry -> parse_param ;

statement-entry -> parse_stmt ;

initialiser-entry -> parse_init ;

hash-if-expression -> parse_nat ;

template-type-param -> parse_type_param ;

constant-offset -> parse_offset ;

/*

    BASIC TYPES

    The type BOOL is used to hold the predicate values, true and false.

    The type COUNT is used to hold the various counters maintained (see

    predict.c).  The type LEX is used to hold a lexical token number

    (i.e.  one of the values defined in syntax.h).  The other types used

    in the parser map in a simple fashion to the main program types.

    Note that it is necessary to use aliases for compound types because

    of the restrictions imposed by sid.

*/

BOOL -> int ;

BTYPE -> BASE_TYPE ;

CONDITION -> unsigned ;

COUNT -> int ;

CV -> CV_SPEC ;

DECL -> IDENTIFIER ;

DSPEC -> DECL_SPEC ;

EXP -> EXP ;

IDENTIFIER -> IDENTIFIER ;

KEY -> BASE_TYPE ;

LEX -> int ;

LIST-EXP -> SID_LIST_EXP ;

NAMESPACE -> NAMESPACE ;

NUMBER -> int ;

OFFSET -> OFFSET ;

TYPE -> TYPE ;

/*

    FILE HEADERS

    These headers are prepended to the parser definition and declaration

    output files.  Because of the simple file splitting algorithm applied

    to the output this should contain only declarations and not definitions.

*/

%header% @{

/*

    		 Crown Copyright (c) 1997, 1998

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

#include "config.h"

#include "c_types.h"

#include "exp_ops.h"

#include "hashid_ops.h"

#include "id_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "access.h"

#include "allocate.h"

#include "assign.h"

#include "basetype.h"

#include "cast.h"

#include "chktype.h"

#include "class.h"

#include "constant.h"

#include "construct.h"

#include "convert.h"

#include "declare.h"

#include "derive.h"

#include "dump.h"

#include "exception.h"

#include "expression.h"

#include "function.h"

#include "hash.h"

#include "identifier.h"

#include "initialise.h"

#include "inttype.h"

#include "label.h"

#include "lex.h"

#include "literal.h"

#include "member.h"

#include "namespace.h"

#include "parse.h"

#include "pragma.h"

#include "predict.h"

#include "preproc.h"

#include "redeclare.h"

#include "rewrite.h"

#include "statement.h"

#include "symbols.h"

#include "template.h"

#include "tokdef.h"

#include "token.h"

#include "typeid.h"

#include "variable.h"

/*

    COMPOUND TYPE ALIASES

    These are the aliases for the compound types used in the parser.

*/

typedef LIST ( EXP ) SID_LIST_EXP ;

/*

    FUNCTION DECLARATIONS

    The function declarations are included at this point so that the

    type definitions are in scope.

*/

#include "syntax.h"

/*

    COMPILATION MODE

    The output of sid is automatically generated.  Hence it is not

    necessarily appropriate to apply the same level of checking to this

    as to the rest of the program.  These pragmas describe the relaxations

    allowed for the sid output.

*/

#if FS_TENDRA

#pragma TenDRA begin

#pragma TenDRA const conditional allow

#pragma TenDRA unreachable code allow

#pragma TenDRA variable analysis off

#endif

@}, @{

/*

    		 Crown Copyright (c) 1997, 1998

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

#ifndef SYNTAX_INCLUDED

#define SYNTAX_INCLUDED

@} ;

%terminals%

/*

    IDENTIFIER TERMINALS

    Identifiers and related terminals (type names, namespace names and

    destructor names) are identified by means of an identifier stored in

    crt_token by expand_token.

*/

identifier : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

type-name : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

namespace-name : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

statement-name : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

destructor-name : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

template-id : () -> ( id ) = @{

    IDENTIFIER id = crt_token->pp_data.tok.id ;

    PPTOKEN *args = crt_token->pp_data.tok.args ;

    @id = parse_id_template ( id, args, 0 ) ;

    RESCAN_LEXER ;

@} ;

template-type : () -> ( id ) = @{

    IDENTIFIER id = crt_token->pp_data.tok.id ;

    PPTOKEN *args = crt_token->pp_data.tok.args ;

    @id = parse_type_template ( id, args, 0 ) ;

    RESCAN_LEXER ;

@} ;

/*

    NAMESPACE SPECIFIER TERMINALS

    Namespace specifiers (i.e. sequences of namespace or class names

    separated using '::') are identified by expand_token.  The full nested

    names are those which begin with the global namespace.

*/

nested-name : () -> ( ns ) = @{

    @ns = crt_token->pp_data.ns ;

@} ;

full-name : () -> ( ns ) = @{

    @ns = crt_token->pp_data.ns ;

@} ;

/*

    POINTER TO MEMBER TERMINALS

    Pointer to member specifiers (such as 'C::*') are identified by

    expand_token.  The identifier corresponding to the given class is

    stored in crt_token.

*/

nested-name-star : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

full-name-star : () -> ( id ) = @{

    @id = crt_token->pp_data.id.use ;

@} ;

/*

    INTEGER AND FLOATING-POINT LITERAL TERMINALS

    Integer and floating-point literal tokens have already been transformed

    into their corresponding expressions by expand_token, which stores this

    information in crt_token.

*/

integer-exp : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

floating-exp : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

/*

    STRING AND CHARACTER LITERAL TERMINALS

    String and character literal tokens have already been transformed

    into their corresponding expressions by expand_token, which stores this

    information in crt_token.

*/

char-exp : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

wchar-exp : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

string-exp : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

wstring-exp : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

/*

    CONDITIONAL COMPILATION TERMINALS

    Any target dependent conditional compilation expressions are stored

    in crt_token by the preprocessing routines.

*/

hash-if : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

hash-elif : () -> ( e ) = @{

    @e = crt_token->pp_data.exp ;

@} ;

/*

    COMPLEX EXPRESSION AND TYPE TERMINALS

    These terminals are used to handle complex expressions and types

    such as token applications.

*/

complex-exp : () -> ( e ) = @{

    IDENTIFIER id = crt_token->pp_data.tok.id ;

    PPTOKEN *args = crt_token->pp_data.tok.args ;

    @e = parse_exp_token ( id, args ) ;

    RESCAN_LEXER ;

@} ;

complex-stmt : () -> ( e ) = @{

    IDENTIFIER id = crt_token->pp_data.tok.id ;

    PPTOKEN *args = crt_token->pp_data.tok.args ;

    @e = parse_exp_token ( id, args ) ;

    RESCAN_LEXER ;

@} ;

complex-type : () -> ( t ) = @{

    IDENTIFIER id = crt_token->pp_data.tok.id ;

    PPTOKEN *args = crt_token->pp_data.tok.args ;

    @t = parse_type_token ( id, args ) ;

    have_type_declaration = TYPE_DECL_NONE ;

    have_type_specifier = 1 ;

    RESCAN_LEXER ;

@} ;

%actions%

/*

    LEXICAL TOKENS

    These actions give the basic values for the type LEX.  They are used

    primarily in overloaded operator function names, but they are also used

    to distinguish closely related groups of expressions, such as relational

    expressions.  Note that the primary form of the token has been given

    whenever there is a choice, otherwise the actions are very dull.

*/

<lex_crt> : () -> ( t ) = @{ @t = crt_lex_token ; @} ;

<lex_open_round> : () -> ( t ) = @{ @t = lex_open_Hround ; @} ;

<lex_semicolon> : () -> ( t ) = @{ @t = lex_semicolon ; @} ;

<lex_alignof> : () -> ( t ) = @{ @t = lex_alignof ; @} ;

<lex_sizeof> : () -> ( t ) = @{ @t = lex_sizeof ; @} ;

/*

    SPECIAL FUNCTION IDENTIFIERS

    These actions are used to construct the identifiers corresponding to

    the operator-function-ids and conversion-function-ids.  In addition,

    id_none gives the null identifier and id_anon generates a unique

    anonymous identifier.

*/

<id_none> : () -> ( id ) = @{

    @id = NULL_id ;

@} ;

<id_anon> : () -> ( id ) = @{

    HASHID nm = lookup_anon () ;

    @id = DEREF_id ( hashid_id ( nm ) ) ;

@} ;

/*

    NAMESPACES AND IDENTIFIER LOOK-UP

    These actions are used to identify namespaces and identifiers within

    those namespaces.

*/

<rescan_member> : ( ns, id ) -> ( n ) = @{

    HASHID nm = DEREF_hashid ( id_name ( @id ) ) ;

    @n = find_qual_id ( @ns, nm, 1, 0 ) ;

@} ;

/*

    LISTS OF EXPRESSIONS

    These actions give the basic constructs for building up lists of

    expressions.  They map directly to the calculus list operations.

*/

<list_exp_null> : () -> ( p ) = @{

    @p = NULL_list ( EXP ) ;

@} ;

<list_exp_cons> : ( e, q ) -> ( p ) = @{

    CONS_exp ( @e, @q, @p ) ;

@} ;

/*

    EXPRESSION CONSTRUCTORS

    These actions describe how to build up expressions from more primitive

    expressions.  The null expression, exp_none, is used to indicate that

    an optional expression is absent.  Most of the actions are very

    straightforward, either directly calling a calculus EXP constructor

    or the appropriate expression construction function.

*/

<exp_none> : () -> ( e ) = @{

    @e = NULL_exp ;

@} ;

<exp_aggregate> : ( p ) -> ( e ) = @{

    /* The expression type is a dummy */

    MAKE_exp_aggregate ( type_void, @p, NULL_list ( OFFSET ), @e ) ;

@} ;

<exp_and> : ( a, b ) -> ( e ) = @{

    @e = make_and_exp ( @a, @b ) ;

@} ;

<exp_arrow_begin> : ( a ) -> ( e, t, ns ) = @{

    @e = begin_field_exp ( lex_arrow, @a, &@t, &@ns ) ;

@} ;

<exp_arrow_end> : ( a, t, ns, id ) -> ( e ) = @{

    @e = end_field_exp ( lex_arrow, @a, @t, @ns, @id, 0 ) ;

@} ;

<exp_assign> : ( a, b ) -> ( e ) = @{

    @e = make_assign_exp ( @a, @b, 1 ) ;

@} ;

<exp_assign_op> : ( op, a, b ) -> ( e ) = @{

    /* op will be in its primary form */

    @e = make_become_exp ( @op, @a, @b ) ;

@} ;

<exp_cast> : ( t, a, n ) -> ( e ) = @{

    /* n is the number of type definitions in t */

    @e = make_cast_exp ( @t, @a, @n ) ;

@} ;

<exp_comma> : ( p ) -> ( e ) = @{

    @e = make_comma_exp ( @p ) ;

@} ;

<exp_cond> : ( a, b, c ) -> ( e ) = @{

    @e = make_cond_exp ( @a, @b, @c ) ;

@} ;

<exp_div> : ( a, b ) -> ( e ) = @{

    @e = make_mult_exp ( lex_div, @a, @b ) ;

@} ;

<exp_dot_begin> : ( a ) -> ( e, t, ns ) = @{

    @e = begin_field_exp ( lex_dot, @a, &@t, &@ns ) ;

@} ;

<exp_dot_end> : ( a, t, ns, id ) -> ( e ) = @{

    @e = end_field_exp ( lex_dot, @a, @t, @ns, @id, 0 ) ;

@} ;

<exp_ellipsis> : () -> ( e ) = @{

    @e = make_ellipsis_exp () ;

@} ;

<exp_equality> : ( op, a, b ) -> ( e ) = @{

    /* op will be in its primary form */

    @e = make_equality_exp ( @op, @a, @b ) ;

@} ;

<exp_eval> : ( a ) -> ( e ) = @{

    @e = convert_reference ( @a, REF_NORMAL ) ;

    @e = convert_lvalue ( @e ) ;

@} ;

<exp_func> : ( a, p ) -> ( e ) = @{

    @e = make_func_exp ( @a, @p, 0 ) ;

@} ;

<exp_identifier> : ( id ) -> ( e ) = @{

    @e = make_id_exp ( @id ) ;

@} ;

<exp_ignore> : ( a ) -> ( e ) = @{

    @e = make_cast_exp ( type_void, @a, 0 ) ;

@} ;

<exp_index> : ( a, b ) -> ( e ) = @{

    @e = make_index_exp ( @a, @b ) ;

@} ;

<exp_indir> : ( a ) -> ( e ) = @{

    @e = make_indir_exp ( @a ) ;

@} ;

<exp_location> : ( a ) -> ( e ) = @{

    MAKE_exp_location ( type_void, crt_loc, @a, @e ) ;

@} ;

<exp_log_and> : ( a, b ) -> ( e ) = @{

    @e = make_log_and_exp ( @a, @b ) ;

@} ;

<exp_log_or> : ( a, b ) -> ( e ) = @{

    @e = make_log_or_exp ( @a, @b ) ;

@} ;

<exp_lshift> : ( a, b ) -> ( e ) = @{

    @e = make_shift_exp ( lex_lshift, @a, @b ) ;

@} ;

<exp_maxmin> : ( op, a, b ) -> ( e ) = @{

    @e = make_mult_exp ( @op, @a, @b ) ;

@} ;

<exp_minus> : ( a, b ) -> ( e ) = @{

    @e = make_minus_exp ( @a, @b ) ;

@} ;

<exp_mult> : ( a, b ) -> ( e ) = @{

    @e = make_mult_exp ( lex_star, @a, @b ) ;

@} ;

<exp_not> : ( a ) -> ( e ) = @{

    @e = make_not_exp ( @a ) ;

@} ;

<exp_or> : ( a, b ) -> ( e ) = @{

    @e = make_or_exp ( @a, @b ) ;

@} ;

<exp_paren_begin> : () -> () = @{

    IGNORE incr_value ( OPT_VAL_paren_depth ) ;

@} ;

<exp_paren_end> : ( a ) -> ( e ) = @{

    @e = make_paren_exp ( @a ) ;

    decr_value ( OPT_VAL_paren_depth ) ;

@} ;

<exp_plus> : ( a, b ) -> ( e ) = @{

    @e = make_plus_exp ( @a, @b ) ;

@} ;

<exp_postdec> : ( a ) -> ( e ) = @{

    @e = make_postfix_exp ( lex_minus_Hminus, @a ) ;

@} ;

<exp_postinc> : ( a ) -> ( e ) = @{

    @e = make_postfix_exp ( lex_plus_Hplus, @a ) ;

@} ;

<exp_predec> : ( a ) -> ( e ) = @{

    @e = make_prefix_exp ( lex_minus_Hminus, @a ) ;

@} ;

<exp_preinc> : ( a ) -> ( e ) = @{

    @e = make_prefix_exp ( lex_plus_Hplus, @a ) ;

@} ;

<exp_ref> : ( a ) -> ( e ) = @{

    @e = make_ref_exp ( @a, 0 ) ;

@} ;

<exp_relation> : ( op, a, b ) -> ( e ) = @{

    /* op will be in its primary form */

    @e = make_relation_exp ( @op, @a, @b ) ;

@} ;

<exp_rem> : ( a, b ) -> ( e ) = @{

    @e = make_rem_exp ( @a, @b ) ;

@} ;

<exp_rshift> : ( a, b ) -> ( e ) = @{

    @e = make_shift_exp ( lex_rshift, @a, @b ) ;

@} ;

<exp_set> : ( a ) -> ( e ) = @{

    @e = make_set_exp ( @a ) ;

@} ;

<exp_sizeof> : ( op, t, a, n ) -> ( e ) = @{

    @e = make_sizeof_exp ( @t, @a, @n, @op ) ;

@} ;

<exp_unary> : ( op, a ) -> ( e ) = @{

    @e = make_uminus_exp ( @op, @a ) ;

@} ;

<exp_unused> : ( a ) -> ( e ) = @{

    @e = make_unused_exp ( @a ) ;

@} ;

<exp_xor> : ( a, b ) -> ( e ) = @{

    @e = make_xor_exp ( @a, @b ) ;

@} ;

/*

    STATEMENT CONSTRUCTORS

    These actions describe how to build up statements from expressions,

    declarations, and more primitive statements.  The empty statement is

    represented by the null expression, stmt_none.  The other statement

    constructors map directly onto constructor functions.

*/

<stmt_none> : () -> ( e ) = @{

    @e = NULL_exp ;

@} ;

<stmt_break> : () -> ( e ) = @{

    @e = make_break_stmt () ;

@} ;

<stmt_case_begin> : ( a ) -> ( e ) = @{

    @e = begin_case_stmt ( @a, 0 ) ;

@} ;

<stmt_case_end> : ( a, b ) -> ( e ) = @{

    @e = end_case_stmt ( @a, @b ) ;

@} ;

<stmt_compound_begin> : () -> ( e ) = @{

    @e = begin_compound_stmt ( 1 ) ;

@} ;

<stmt_compound_mark> : ( a ) -> () = @{

    mark_compound_stmt ( @a ) ;

@} ;

<stmt_compound_block> : ( a ) -> ( b ) = @{

    COPY_int ( exp_sequence_block ( @a ), 2 ) ;

    @b = 1 ;

@} ;

<stmt_compound_add> : ( a, b ) -> ( e ) = @{

    @e = add_compound_stmt ( @a, @b ) ;

@} ;

<stmt_compound_end> : ( a ) -> ( e ) = @{

    @e = end_compound_stmt ( @a ) ;

@} ;

<stmt_continue> : () -> ( e ) = @{

    @e = make_continue_stmt () ;

@} ;

<stmt_decl> : () -> ( e ) = @{

    in_declaration-- ;

    @e = NULL_exp ;

@} ;

<stmt_default_begin> : () -> ( e ) = @{

    @e = begin_default_stmt ( 0 ) ;

@} ;

<stmt_default_end> : ( a, b ) -> ( e ) = @{

    @e = end_default_stmt ( @a, @b ) ;

@} ;

<stmt_do_begin> : () -> ( e ) = @{

    @e = begin_do_stmt () ;

@} ;

<stmt_do_end> : ( a, b, c ) -> ( e ) = @{

    @e = end_do_stmt ( @a, @b, @c ) ;

@} ;

<stmt_exp> : ( a ) -> ( e ) = @{

    @e = make_exp_stmt ( @a ) ;

@} ;

<stmt_for_begin> : () -> ( e ) = @{

    @e = begin_for_stmt () ;

@} ;

<stmt_for_init> : ( a, b ) -> ( e ) = @{

    @e = init_for_stmt ( @a, &@b ) ;

@} ;

<stmt_for_cond> : ( a, b, c ) -> ( e ) = @{

    @e = cond_for_stmt ( @a, @b, @c ) ;

@} ;

<stmt_for_end> : ( a, b ) -> ( e ) = @{

    @e = end_for_stmt ( @a, @b ) ;

@} ;

<stmt_goto> : ( id ) -> ( e ) = @{

    @e = make_goto_stmt ( @id ) ;

@} ;

<stmt_goto_case> : ( a ) -> ( e ) = @{

    report ( crt_loc, ERR_stmt_goto_case ( lex_case ) ) ;

    @e = begin_case_stmt ( @a, 1 ) ;

@} ;

<stmt_goto_default> : () -> ( e ) = @{

    report ( crt_loc, ERR_stmt_goto_case ( lex_default ) ) ;

    @e = begin_default_stmt ( 1 ) ;

@} ;

<stmt_if_begin> : ( a ) -> ( e ) = @{

    @e = begin_if_stmt ( @a ) ;

@} ;

<stmt_if_cont> : ( a, b ) -> ( e ) = @{

    @e = cont_if_stmt ( @a, @b ) ;

@} ;

<stmt_if_end> : ( a, b ) -> ( e ) = @{

    @e = end_if_stmt ( @a, @b ) ;

@} ;

<stmt_else> : () -> () = @{

    check_empty_stmt ( lex_else ) ;

@} ;

<stmt_no_else> : () -> ( e ) = @{

    report ( crt_loc, ERR_stmt_if_no_else () ) ;

    @e = NULL_exp ;

@} ;

<stmt_label_begin> : ( id ) -> ( e ) = @{

    @e = begin_label_stmt ( @id, lex_identifier ) ;

@} ;

<stmt_label_end> : ( a, b ) -> ( e ) = @{

    @e = end_label_stmt ( @a, @b ) ;

@} ;

<stmt_label_set> : () -> () = @{

    unreached_fall = 0 ;

@} ;

<stmt_label_clear> : () -> () = @{

    unreached_fall = 1 ;

@} ;

<stmt_label_mod> : () -> () = @{

    if ( unreached_code ) unreached_fall = 0 ;

@} ;

<stmt_return> : ( a ) -> ( e ) = @{

    @e = make_return_stmt ( @a, lex_return ) ;

@} ;

<stmt_return_fall> : () -> ( e ) = @{

    @e = fall_return_stmt () ;

@} ;

<stmt_switch_begin> : ( a ) -> ( e ) = @{

    @e = begin_switch_stmt ( @a ) ;

@} ;

<stmt_switch_end> : ( a, b, ex ) -> ( e ) = @{

    @e = end_switch_stmt ( @a, @b, @ex ) ;

@} ;

<stmt_while_begin> : ( a ) -> ( e ) = @{

    @e = begin_while_stmt ( @a ) ;

@} ;

<stmt_while_end> : ( a, b ) -> ( e ) = @{

    @e = end_while_stmt ( @a, @b ) ;

@} ;

<stmt_hash_if> : ( a, b ) -> ( e ) = @{

    @e = begin_hash_if_stmt ( @a, @b ) ;

@} ;

<stmt_hash_elif> : ( a, b, c ) -> ( e ) = @{

    @e = cont_hash_if_stmt ( @a, @b, @c ) ;

@} ;

<stmt_hash_endif> : ( a, b ) -> ( e ) = @{

    @e = end_hash_if_stmt ( @a, @b ) ;

@} ;

<stmt_reach> : ( a ) -> ( e ) = @{

    @e = make_reach_stmt ( @a, 1 ) ;

@} ;

<stmt_unreach> : ( a ) -> ( e ) = @{

    @e = make_reach_stmt ( @a, 0 ) ;

@} ;

<bind_temporary> : ( a ) -> ( e ) = @{

    @e = bind_temporary ( @a ) ;

@} ;

/*

    FLOW ANALYSIS

    These actions are concerned with flow and variable analysis.

*/

<reach_check> : () -> ( r ) = @{

    @r = unreached_code ;

    if ( @r ) {

	if ( !unreached_last ) {

	    report ( crt_loc, ERR_stmt_stmt_unreach () ) ;

	    unreached_last = 1 ;

	}

    } else {

	unreached_last = 0 ;

    }

@} ;

<reach_prev> : ( r ) -> () = @{ unreached_prev = @r ; @} ;

<reach_set> : () -> () = @{ unreached_code = 0 ; @} ;

<reach_unset> : () -> () = @{ unreached_code = 1 ; @} ;

<condition_get> : () -> ( c ) = @{ @c = crt_condition ; @} ;

<condition_set> : ( c ) -> () = @{ crt_condition = @c ; @} ;

/*

    FUNCTION DEFINITIONS CONSTRUCTORS

    These actions are called at the start and the end of a function

    definition.  Most of the work is done by construction functions, but

    the flags have_type_declaration and in_function_defn are handled

    locally.

*/

<function_begin> : ( d ) -> ( b ) = @{

    @b = in_class_defn ;

    in_class_defn = 0 ;

    in_function_defn++ ;

    really_in_function_defn++ ;

    begin_function ( @d ) ;

@} ;

<function_end> : ( d, a, b ) -> () = @{

    IGNORE end_function ( @d, @a ) ;

    in_class_defn = @b ;

    in_function_defn-- ;

    really_in_function_defn-- ;

@} ;

<param_begin> : ( id ) -> () = @{

    func_type_defn ( 0 ) ;

    begin_param ( @id ) ;

    have_type_declaration = TYPE_DECL_NONE ;

    have_func_declarator = 0 ;

@} ;

<param_end> : () -> () = @{

    end_param () ;

    have_type_declaration = TYPE_DECL_NONE ;

    have_func_declarator = 1 ;

@} ;

/*

    CONST-VOLATILE QUALIFIERS

    These actions describe how to construct and combine the const and

    volatile type qualifiers.  The main action is cv_join which combines

    two CV bitmasks by bitwise or'ing them.  It also checks for

    duplicate qualifiers.

*/

<cv_none> : () -> ( cv ) = @{ @cv = cv_none ; @} ;

<cv_const> : () -> ( cv ) = @{ @cv = cv_const ; @} ;

<cv_volatile> : () -> ( cv ) = @{ @cv = cv_volatile ; @} ;

<cv_join> : ( a, b ) -> ( cv ) = @{

    CV_SPEC c = ( @a & @b ) ;

    if ( c ) report ( crt_loc, ERR_dcl_type_cv_dup ( c ) ) ;

    @cv = ( @a | @b ) ;

@} ;

/*

    BASIC TYPES

    These actions describe the basic type specifiers, char, short, int,

    and so on.  This is a simple map onto the calculus type BTYPE.

*/

<btype_char> : () -> ( bt ) = @{ @bt = btype_char ; @} ;

<btype_short> : () -> ( bt ) = @{ @bt = btype_short ; @} ;

<btype_int> : () -> ( bt ) = @{ @bt = btype_int ; @} ;

<btype_long> : () -> ( bt ) = @{ @bt = btype_long ; @} ;

<btype_signed> : () -> ( bt ) = @{ @bt = btype_signed ; @} ;

<btype_unsigned> : () -> ( bt ) = @{ @bt = btype_unsigned ; @} ;

<btype_float> : () -> ( bt ) = @{ @bt = btype_float ; @} ;

<btype_double> : () -> ( bt ) = @{ @bt = btype_double ; @} ;

<btype_wchar_t> : () -> ( bt ) = @{ @bt = btype_wchar_t ; @} ;

<btype_size_t> : () -> ( bt ) = @{ @bt = btype_size_t ; @} ;

<btype_ptrdiff_t> : () -> ( bt ) = @{ @bt = btype_ptrdiff_t ; @} ;

<btype_void> : () -> ( bt ) = @{ @bt = btype_void ; @} ;

<btype_bottom> : () -> ( bt ) = @{ @bt = btype_bottom ; @} ;

<btype_none> : () -> ( bt ) = @{ @bt = btype_none ; @} ;

<btype_join> : ( b1, b2 ) -> ( bt ) = @{

    if ( @b1 & @b2 ) {

	@bt = join_pre_types ( @b1, @b2 ) ;

    } else {

	@bt = ( @b1 | @b2 ) ;

    }

@} ;

/*

    BASIC TYPE CONSTRUCTORS

    These actions describe how to combine the basic types into real type

    descriptors.  The null type, type_none, is used to indicate the absence

    of an optional type.  A base type specifier can be transformed into a

    partial type by type_pre, and a type name by type_name.  Two partial

    types may be combined using type_join.  A partial type may be turned

    into a real type by type_complete, which also checks that the resultant

    type is not an inferred type (also see dspec_complete).

*/

<type_none> : () -> ( t ) = @{

    @t = NULL_type ;

@} ;

<type_pre> : () -> ( t ) = @{

    @t = NULL_type ;

    have_type_specifier = 1 ;

@} ;

<type_name> : ( id ) -> ( t ) = @{

    MAKE_type_pre ( cv_none, btype_alias, qual_none, @t ) ;

    COPY_id ( type_name ( @t ), @id ) ;

    have_type_specifier = 1 ;

@} ;

<type_elaborate> : ( id, k ) -> ( t ) = @{

    MAKE_type_pre ( cv_none, @k, qual_none, @t ) ;

    COPY_id ( type_name ( @t ), @id ) ;

    if ( have_type_declaration == TYPE_DECL_NONE ) {

	have_type_declaration = TYPE_DECL_ELABORATE ;

    }

    have_type_specifier = 1 ;

@} ;