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_ ;

type = XT ;

function = XR ;

input = XI ;

output = XO ;

label = XL ;

%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.

*/

pragma-tendra -> parse_tendra ;

pragma-preproc -> parse_preproc ;

/*

    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.

*/

ACCESS -> DECL_SPEC ;

BOOL -> int ;

BTYPE -> BASE_TYPE ;

CV -> CV_SPEC ;

EXP -> EXP ;

IDENTIFIER -> IDENTIFIER ;

LEX -> int ;

LINKAGE -> DECL_SPEC ;

LIST-ID -> SID_LIST_ID ;

NAMESPACE -> NAMESPACE ;

NUMBER -> int ;

STATE -> unsigned ;

TOKEN -> TOKEN ;

TYPE -> TYPE ;

VALUE -> unsigned ;

/*

    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 "tok_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 "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 "printf.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(IDENTIFIER) SID_LIST_ID;

/*

     DECLARE FUNCTIONS

     The function declarations are included at this point so that the

     type definitions are in scope.

*/

#include "psyntax.h"

extern void parse_tok_type(TYPE *);

extern void parse_mem_type(TYPE *);

extern void parse_operator(IDENTIFIER *);

/*

    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 variable analysis off

#ifndef OLD_PRODUCER

#pragma TenDRA unreachable code allow

#endif

#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 PSYNTAX_INCLUDED

#define PSYNTAX_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 ) ;

    crt_templ_qualifier = 1 ;

    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 ) ;

    crt_templ_qualifier = 1 ;

    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%

/*

    LINKS TO MAIN SYNTAX

    These actions give links into the main syntax.  Note that none of the

    used rules in the main syntax has an associated exception handler,

    allowing syntax errors to be handled in the pragma syntax.

*/

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

    @t = type_error ;

    parse_tok_type ( &@t ) ;

    object_type ( @t, null_tag ) ;

@} ;

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

    @t = type_error ;

    parse_tok_type ( &@t ) ;

    object_type ( @t, id_function_tag ) ;

@} ;

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

    @t = type_error ;

    parse_mem_type ( &@t ) ;

    object_type ( @t, null_tag ) ;

@} ;

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

    @id = DEREF_id ( hashid_id ( KEYWORD ( lex_zzzz ) ) ) ;

    parse_operator ( &@id ) ;

@} ;

<is_operator> : () -> ( b ) = @{

    @b = predict_operator () ;

@} ;

/*

    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_asm> : () -> ( t ) = @{ @t = lex_asm ; @} ;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @t = crt_lex_token ;

    if ( @t >= FIRST_SYMBOL && @t <= LAST_SYMBOL ) crt_lex_token = lex_plus ;

@} ;

/*

    SPECIAL IDENTIFIERS

    id_none gives the null identifier and id_anon generates a unique

    anonymous identifier.

*/

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

    @id = NULL_id ;

    crt_id_qualifier = qual_none ;

    qual_namespace = NULL_nspace ;

@} ;

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

    HASHID nm = lookup_anon () ;

    @id = DEREF_id ( hashid_id ( nm ) ) ;

    crt_id_qualifier = qual_none ;

    qual_namespace = NULL_nspace ;

@} ;

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

    @e = NULL_exp ;

@} ;

/*

    CONST-VOLATILE QUALIFIERS

    These actions describe how to construct and combine the const and

    volatile type qualifiers.

*/

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

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

/*

    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_signed> : () -> ( bt ) = @{ @bt = btype_signed ; @} ;

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

<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_none> : () -> ( bt ) = @{ @bt = btype_none ; @} ;

/*

    ACCESS SPECIFIERS

    These actions describe the access specifiers, private, protected and

    public.

*/

<access_private> : () -> ( a ) = @{ @a = dspec_private ; @} ;

<access_protected> : () -> ( a ) = @{ @a = dspec_protected ; @} ;

<access_public> : () -> ( a ) = @{ @a = dspec_public ; @} ;

/*

    LINKAGE SPECIFIERS

    These actions describe the linkage specifiers.  These are implemented

    by a simple global variable, crt_linkage.  The action linkage_string

    translates a string literal expression into a linkage specifier.

*/

<linkage_string> : ( s ) -> ( a ) = @{

    @a = find_linkage ( @s ) ;

@} ;

/*

    OBJECT DECLARATIONS

    These actions describe how to construct an object declaration.

*/

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

    crt_templ_qualifier = 0 ;

@} ;

/*

    LISTS OF IDENTIFIERS

    These actions give the basic constructs for building up lists of

    identifiers.  They map directly to the calculus list operations.

*/

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

    @p = NULL_list ( IDENTIFIER ) ;

@} ;

<list_id_cons> : ( id, q ) -> ( p ) = @{

    CONS_id ( @id, @q, @p ) ;

@} ;

/*

    TOKEN ACTIONS

    The following rules are concerned with the construction and definition

    of TDF tokens.

*/

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

    MAKE_tok_nat ( NULL_nat, @t ) ;

@} ;

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

    MAKE_tok_snat ( NULL_nat, @t ) ;

@} ;

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

    MAKE_tok_stmt ( NULL_exp, @t ) ;

@} ;

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

    @t = make_type_token ( btype_none ) ;

@} ;

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

    @t = make_type_token ( btype_int ) ;

@} ;

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

    @t = make_type_token ( btype_signed | btype_int ) ;

@} ;

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

    @t = make_type_token ( btype_unsigned | btype_int ) ;

@} ;

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

    @t = make_type_token ( btype_float ) ;

@} ;

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

    @t = make_type_token ( btype_arith ) ;

@} ;

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

    @t = make_type_token ( btype_lang ) ;

@} ;

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

    @t = make_type_token ( btype_scalar ) ;

@} ;

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

    @t = make_type_token ( btype_struct ) ;

@} ;

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

    @t = make_type_token ( btype_union ) ;

@} ;

<token_exp> : ( a, c, b ) -> ( t ) = @{

    @t = make_exp_token ( @b, @a, @c ) ;

@} ;

<token_member> : ( p, a, b ) -> ( t ) = @{

    @t = make_member_token ( @a, @b, @p ) ;

@} ;

<token_func> : ( a ) -> ( t ) = @{

    @t = make_func_token ( @a ) ;

@} ;

<token_param> : ( t, b, tid ) -> ( id ) = @{

    @id = make_tok_param ( @t, @b, @tid ) ;

@} ;

<token_exp_par> : ( tid, r ) -> ( id ) = @{

    @id = prog_tok_param ( @tid, NULL_type, tok_exp_tag, @r ) ;

@} ;

<token_stmt_par> : ( tid, r ) -> ( id ) = @{

    @id = prog_tok_param ( @tid, NULL_type, tok_stmt_tag, @r ) ;

@} ;

<token_type_par> : ( t, r ) -> ( id ) = @{

    IDENTIFIER tid = DEREF_id ( type_name ( @t ) ) ;

    @id = prog_tok_param ( tid, @t, tok_type_tag, @r ) ;

@} ;

<token_member_par> : ( t, tid, r ) -> ( id ) = @{

    @id = prog_tok_param ( @tid, @t, tok_member_tag, @r ) ;

@} ;

<token_proc_par> : ( tid, r ) -> ( id ) = @{

    @id = prog_tok_param ( @tid, NULL_type, tok_proc_tag, @r ) ;

@} ;

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

    @t = begin_proc_token () ;

@} ;

<token_proc_simple> : ( a, p ) -> ( t ) = @{

    @t = cont_proc_token ( @a, @p, @p ) ;

@} ;

<token_proc_complex> : ( a, p, q ) -> ( t ) = @{

    @t = cont_proc_token ( @a, @p, @q ) ;

@} ;

<token_proc_end> : ( a, b ) -> ( t ) = @{

    @t = end_proc_token ( @a, @b ) ;

@} ;

<token_decl> : ( t, c, a, b ) -> () = @{

    IGNORE make_token_decl ( @t, @c, @a, @b ) ;

@} ;

<token_name> : ( a ) -> ( id ) = @{

    @id = check_id ( crt_namespace, @a, 0 ) ;

@} ;

<token_tag> : ( a ) -> ( id ) = @{

    @id = find_tag_token ( @a ) ;

@} ;

<token_selector> : ( a, b ) -> ( id ) = @{

    @id = find_mem_token ( @a, @b ) ;

@} ;

<token_extern> : ( a ) -> ( id ) = @{

    @id = find_ext_token ( @a ) ;

@} ;

<token_interface> : ( id, i ) -> () = @{

    token_interface ( @id, @i ) ;

@} ;

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

    if ( define_mem_macro ( @id, @t ) ) no_declarations++ ;

@} ;

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

    in_token_decl = 1 ;

@} ;

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

    in_token_decl = 0 ;

@} ;

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

    allow_conversion ( @id ) ;

@} ;

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

    allow_initialiser ( @id ) ;

@} ;

<id_postpone> : ( id, a ) -> () = @{

    preserve_id ( @id, @a ) ;

@} ;

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

    preserve_id ( @id, lex_preserve ) ;

@} ;

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

    preserve_all = 1 ;

@} ;

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

    preserve_id ( @id, lex_suspend ) ;

@} ;

<interface_define> : () -> ( i ) = @{ @i = lex_define ; @} ;

<interface_no_def> : () -> ( i ) = @{ @i = lex_no_Hdef ; @} ;

<interface_ignore> : () -> ( i ) = @{ @i = lex_ignore ; @} ;

<interface_crt> : () -> ( i ) = @{ @i = crt_interface ; @} ;

<interface_undef> : () -> ( i ) = @{ @i = lex_undef ; @} ;

/*

    INTEGER LITERAL PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with defining integer literal types.

*/

<base_octal> : () -> ( b ) = @{ @b = BASE_OCTAL ; @} ;

<base_decimal> : () -> ( b ) = @{ @b = BASE_DECIMAL ; @} ;

<base_hexadecimal> : () -> ( b ) = @{ @b = BASE_HEXADECIMAL ; @} ;

<suffix_none> : () -> ( s ) = @{ @s = SUFFIX_NONE ; @} ;

<suffix_u> : () -> ( s ) = @{ @s = SUFFIX_U ; @} ;

<suffix_l> : () -> ( s ) = @{ @s = SUFFIX_L ; @} ;

<suffix_ul> : () -> ( s ) = @{ @s = SUFFIX_UL ; @} ;

<suffix_ll> : () -> ( s ) = @{ @s = SUFFIX_LL ; @} ;

<suffix_ull> : () -> ( s ) = @{ @s = SUFFIX_ULL ; @} ;

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

    pragma_number = 1 ;

@} ;

<literal_begin> : ( b, s ) -> () = @{

    begin_literal ( @b, @s ) ;

@} ;

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

    add_range_literal ( NULL_exp, 0 ) ;

@} ;

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

    add_range_literal ( @e, 2 ) ;

@} ;

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

    add_range_literal ( NULL_exp, 1 ) ;

@} ;

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

    add_type_literal ( @t ) ;

@} ;

<literal_token> : ( id, a ) -> () = @{

    add_token_literal ( @id, @a ) ;

@} ;

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

    add_token_literal ( NULL_id, @a ) ;

@} ;

/*

    CHECKING SCOPE PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with defining error checking scopes.

*/

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

    begin_option ( @id ) ;

@} ;

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

    end_option ( 1 ) ;

@} ;

<check_directory> : ( dir, id ) -> () = @{

    directory_option ( @dir, @id ) ;

@} ;

<check_use> : ( id, e ) -> () = @{

    use_option ( @id, @e ) ;

@} ;

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

    begin_decl_block ( @id ) ;

@} ;

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

    IGNORE end_decl_block ( NULL_id, 1 ) ;

@} ;

/*

    ERROR PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with error messages.

*/

<error_number> : ( e ) -> ( n ) = @{

    STRING s = DEREF_str ( exp_string_lit_str ( @e ) ) ;

    @n = find_error_no ( s, 0 ) ;

    if ( @n == -1 ) {

	report ( preproc_loc, ERR_pragma_error_bad ( s ) ) ;

    }

@} ;

<option_number> : ( e ) -> ( n ) = @{

    STRING s = DEREF_str ( exp_string_lit_str ( @e ) ) ;

    @n = find_option_no ( s, 0 ) ;

    if ( @n == -1 ) {

	report ( preproc_loc, ERR_pragma_option_bad ( s ) ) ;

    }

@} ;

<option_value_number> : ( e ) -> ( n ) = @{

    STRING s = DEREF_str ( exp_string_lit_str ( @e ) ) ;

    @n = find_value_no ( s, 0 ) ;

    if ( @n == -1 ) {

	report ( preproc_loc, ERR_pragma_option_bad ( s ) ) ;

    }

@} ;

<error_on> : () -> ( e ) = @{ @e = ( unsigned ) OPTION_ON ; @} ;

<error_off> : () -> ( e ) = @{ @e = ( unsigned ) OPTION_OFF ; @} ;

<error_warning> : () -> ( e ) = @{ @e = ( unsigned ) OPTION_WARN ; @} ;

<error_state> : ( n, e ) -> () = @{

    set_error_sev ( @n, @e ) ;

@} ;

<error_use> : ( n ) -> () = @{

    if ( @n >= 0 ) {

	no_error_args = 1 ;

	report ( crt_loc, make_error ( @n ) ) ;

	no_error_args = 0 ;

    }

@} ;

/*

    TYPE PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with types.

*/

<type_argument> : ( s, t ) -> () = @{

    accept_argument ( @s, @t ) ;

@} ;

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

    accept_ellipsis ( @t ) ;

@} ;

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

    set_char_lit ( @t ) ;

@} ;

<type_char_sign> : ( bt ) -> () = @{

    set_char_sign ( @bt ) ;

@} ;

<type_string_lit> : ( cv ) -> () = @{

    set_string_qual ( @cv ) ;

@} ;

<type_long_long> : ( b ) -> () = @{

    set_long_long_type ( @b ) ;

@} ;

<type_compatible> : ( s, t, e ) -> () = @{

    set_compatible_type ( @s, @t, @e ) ;

@} ;

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

    compute_promote_type ( @id ) ;

@} ;

<type_promote> : ( s, t ) -> () = @{

    set_promote_type ( @s, @t, ntype_ellipsis ) ;

@} ;

<type_builtin> : ( bt, t ) -> () = @{

    set_builtin_type ( @bt, @t ) ;

@} ;

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

    typedef_special ( @id, @t ) ;

@} ;

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

    set_std_namespace ( @id ) ;

@} ;

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

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

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

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

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

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

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

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

/*

    KEYWORD PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with keywords.

*/

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

    @t = find_keyword ( @id ) ;

@} ;

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

    define_keyword ( @id, @t ) ;

@} ;

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

    undef_keyword ( @id ) ;

@} ;

/*

    CHARACTER PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with characters.

*/

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

    set_character ( @a, @b ) ;

@} ;

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

    set_escape ( @a, @b ) ;

@} ;

/*

    CAST PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with explicit casts.

*/

<cast_static> : () -> ( c ) = @{ @c = CAST_STATIC ; @} ;

<cast_reinterp> : () -> ( c ) = @{ @c = CAST_REINTERP ; @} ;

<cast_const> : () -> ( c ) = @{ @c = CAST_CONST ; @} ;

<cast_explicit> : () -> ( c ) = @{ @c = CAST_EXPLICIT ; @} ;

<cast_join> : ( a, b ) -> ( c ) = @{ @c = ( @a | @b ) ; @} ;

/*

    OPTION PRAGMA DIRECTIVES

    The following rules are concerned with processing those '#pragma'

    directives concerned with setting options.

*/

<analysis_state> : ( n, e ) -> () = @{

    set_option ( @n, @e ) ;

@} ;

<analysis_value> : ( n, v ) -> () = @{

    set_value ( @n, NULL_exp, ( unsigned long ) @v ) ;

@} ;

<analysis_exp> : ( n, e ) -> () = @{

    set_value ( @n, @e, ( unsigned long ) 0 ) ;

@} ;

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