Subversion Repositories tendra.SVN

/*

    		 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.

*/

/*

    PRAGMA SYNTAX

    This module gives the syntax for the '#pragma' directives recognised

    by the producer.

*/

/*

    TYPE DECLARATIONS

    The types BOOL, COUNT and LEX are natural types arising from the

    parser.  The remaining types directly correspond to types within the

    main program, or composite types formed from them.

*/

%types%

ACCESS ;

BOOL ;

BTYPE ;

CV ;

EXP ;

IDENTIFIER ;

LEX ;

LINKAGE ;

LIST-ID ;

NAMESPACE ;

NUMBER ;

STATE ;

TOKEN ;

TYPE ;

VALUE ;

/*

    LIST OF TERMINALS

    This list of terminals corresponds to that given in symbols.h and

    syntax.h.

*/

%terminals%

!unknown ;

/* Identifiers */

identifier : () -> ( :IDENTIFIER ) ;

type-name : () -> ( :IDENTIFIER ) ;

namespace-name : () -> ( :IDENTIFIER ) ;

statement-name : () -> ( :IDENTIFIER ) ;

!destructor-name : () -> ( :IDENTIFIER ) ;

!template-id : () -> ( :IDENTIFIER ) ;

!template-type : () -> ( :IDENTIFIER ) ;

/* Nested name specifiers */

!nested-name : () -> ( :NAMESPACE ) ;

!full-name : () -> ( :NAMESPACE ) ;

!nested-name-star : () -> ( :IDENTIFIER ) ;

!full-name-star : () -> ( :IDENTIFIER ) ;

/* Literals */

!char-lit ; !wchar-lit ; !string-lit ; !wstring-lit ; !integer-lit ;

/* Literal expressions */

char-exp : () -> ( :EXP ) ;

wchar-exp : () -> ( :EXP ) ;

string-exp : () -> ( :EXP ) ;

wstring-exp : () -> ( :EXP ) ;

integer-exp : () -> ( :EXP ) ;

!floating-exp : () -> ( :EXP ) ;

/* Token applications */

!complex-exp : () -> ( :EXP ) ;

!complex-stmt : () -> ( :EXP ) ;

!complex-type : () -> ( :TYPE ) ;

/* Target-dependent preprocessing directives */

!hash-if : () -> ( :EXP ) ;

!hash-elif : () -> ( :EXP ) ;

!hash-else ;

!hash-endif ;

!hash-pragma ;

/* End of file markers */

!newline ; !eof ;

/* Symbols */

!and-1 ; !and-eq-1 ; !arrow ; !assign ; !backslash ; close-brace-1 ;

close-round ; !close-square-1 ; colon ; comma ; !compl-1 ; div ; !div-eq ;

dot ; ellipsis ; eq ; !greater ; !greater-eq ; hash-1 ; !hash-hash-1 ;

!less ; !less-eq ; !logical-and-1 ; !logical-or-1 ; !lshift ; !lshift-eq ;

minus ; !minus-eq ; !minus-minus ; !not-1 ; !not-eq-1 ; open-brace-1 ;

open-round ; !open-square-1 ; or-1 ; !or-eq-1 ; plus ; !plus-eq ;

!plus-plus ; question ; !rem ; !rem-eq ; !rshift ; !rshift-eq ;

semicolon ; star ; !star-eq ; !xor-1 ; !xor-eq-1 ; !arrow-star ;

colon-colon ; !dot-star ; !abs ; !max ; !min ;

/* Digraphs */

!close-brace-2 ; !close-square-2 ; !hash-2 ; !hash-hash-2 ;

!open-brace-2 ; !open-square-2 ;

/* C keywords */

auto ; !break ; case ; !char ; const ; !continue ; !default ; !do ;

!double ; !else ; enum ; !extern ; !float ; for ; !goto ; !if ; int ;

long ; !register ; return ; !short ; signed ; !sizeof ; static ; struct ;

switch ; !typedef ; union ; unsigned ; void ; volatile ; !while ;

/* C++ keywords */

asm ; bool ; catch ; !class ; const-cast ; !delete ; !dynamic-cast ;

explicit ; export ; !false ; !friend ; inline ; !mutable ; namespace ;

!new ; operator ; private ; protected ; public ; reinterpret-cast ;

static-cast ; template ; this ; throw ; !true ; !try ; !typeid ;

!typename ; !using ; !virtual ; wchar-t ;

/* ISO keywords */

!and-2 ; !and-eq-2 ; !compl-2 ; !logical-and-2 ; !logical-or-2 ;

!not-2 ; !not-eq-2 ; !or-2 ; !or-eq-2 ; !xor-2 ; !xor-eq-2 ;

/* TenDRA keywords */

accept ; after ; !alignof ; all ; allow ; ambiguous ; analysis ;

argument ; arith-cap ; !array ; as ; assert ; assignment ; begin ;

bitfield ; block ; bottom ; cast ; character ; class-cap ; code ;

comment ; compatible ; complete ; compute ; conditional ; conversion ;

decimal ; decl ; define ; !define-cap ; !defined ; definition ; depth ;

directive ; directory ; disallow ; discard ; dollar ; either ; !elif ;

ellipsis-exp ; end ; !endif ; environment ; equality ; error ; escape ;

exhaustive ; exp-cap ; !explain ; !extend ; external ; extra ; fall ;

file ; float-cap ; forward ; func-cap ; function ; hexadecimal ; hiding ;

ident ; identif ; !ifdef ; !ifndef ; ignore ; !implement ; implicit ;

import ; !include ; includes ; include-next ; incompatible ; incomplete ;

indented ; initialization ; integer ; interface ; internal ; into ;

int-cap ; keyword ; limit ; !line ; linkage ; lit ; longlong ; lvalue ;

macro ; !main ; member ; member-cap ; name ; nat-cap ; nested ; nline ;

no ; no-def ; object ; octal ; of ; off ; on ; option ; overflow ;

overload ; pointer ; postpone ; pragma ; precedence ; preserve ; printf ;

proc-cap ; promote ; promoted ; prototype ; ptrdiff-t ; qualifier ;

quote ; reachable ; !reference ; reject ; representation ; reset ;

resolution ; rvalue ; scalar-cap ; scanf ; set ; size-t ; !size-t-2 ;

!sort ; std ; stmt-cap ; string ; struct-cap ; suspend ; tag ; tag-cap ;

!tendra ; text ; !this-name ; token ; type ; type-cap ; !typeof ;

un-known ; unassert ; undef ; unify ; union-cap ; unmatched ; unpostpone ;

unreachable ; !unused ; use ; value ; variable ; variety-cap ;

volatile-t ; !vtable ; warning ; weak ; writeable ; !zzzz ;

/* Miscellaneous symbols */

!array-op ; !builtin-file ; !builtin-line ; !close-template ; !cond-op ;

!delete-full ; !delete-array ; !delete-array-full ; !func-op ; !hash-op ;

!hash-hash-op ; !inset-start ; !inset-end ; !macro-arg ; !new-full ;

!new-array ; !new-array-full ; !open-init ; !open-template ; !zzzzzz ;

/*

    ALTERNATIVE REPRESENTATIONS

    The ISO keywords and digraphs will have been replaced by their primary

    representations by this stage.  These rules are effectively identities

    for these alternatives.  Don't try removing them - SID gets very

    confused.

*/

%productions%

close-brace =	{ close-brace-1 ; } ;

open-brace =	{ open-brace-1 ; } ;

hash =		{ hash-1 ; } ;

or =		{ or-1 ; } ;

ellipsis-aux =	{ ellipsis ; || ellipsis-exp ; } ;

/*

    IDENTIFIERS

    The identifier terminal is exclusive - it does not include those

    identifiers which are actually type and namespace names.  This rule

    gives all identifiers and sets the appropriate identifier type.

*/

any-identifier : () -> ( id : IDENTIFIER ) = {

	id = identifier ;

    ||	id = type-name ;

    ||	id = namespace-name ;

    ||	id = statement-name ;

} ;

/*

    LITERAL EXPRESSIONS

    These rules describe the literal expressions.  These are the integer

    and floating point literals, the character and string literals, plus

    the boolean literals true and false.  Concatenation of adjacent string

    literals has already been performed.

*/

integer-literal : () -> ( e : EXP ) = {

	e = integer-exp ;

} ;

character-literal : () -> ( e : EXP ) = {

	e = char-exp ;

    ||	e = wchar-exp ;

} ;

string-literal : () -> ( e : EXP ) = {

	e = string-exp ;

    ||	e = wstring-exp ;

} ;

/*

    PROCEDURE TOKEN SYNTAX

    These rules describe the parameter syntax for procedure tokens.

*/

<parse_type> : () -> ( :TYPE ) ;

<parse_mem_type> : () -> ( :TYPE ) ;

<parse_func_type> : () -> ( :TYPE ) ;

<list_id_null> : () -> ( :LIST-ID ) ;

<list_id_cons> : ( :IDENTIFIER, :LIST-ID ) -> ( :LIST-ID ) ;

<token_param> : ( :TOKEN, :BOOL, :IDENTIFIER ) -> ( :IDENTIFIER ) ;

<token_exp_par> : ( :IDENTIFIER, :LIST-ID ) -> ( :IDENTIFIER ) ;

<token_stmt_par> : ( :IDENTIFIER, :LIST-ID ) -> ( :IDENTIFIER ) ;

<token_type_par> : ( :TYPE, :LIST-ID ) -> ( :IDENTIFIER ) ;

<token_member_par> : ( :TYPE, :IDENTIFIER, :LIST-ID ) -> ( :IDENTIFIER ) ;

<token_proc_par> : ( :IDENTIFIER, :LIST-ID ) -> ( :IDENTIFIER ) ;

<id_anon> : () -> ( :IDENTIFIER ) ;

<bool_true> : () -> ( :BOOL ) ;

<bool_false> : () -> ( :BOOL ) ;

<error_comma> : () -> () ;

token-introduction : () -> ( :TOKEN ) ;

tag-opt : () -> ( t : BOOL ) = {

	tag-cap ; t = <bool_true> ;

    ||	t = <bool_false> ;

} ;

bound-tok-param : () -> ( id : IDENTIFIER ) = {

	tok = token-introduction ;

	t = tag-opt ; tid = any-identifier ;

	id = <token_param> ( tok, t, tid ) ;

} ;

bound-tok-pars : () -> ( p : LIST-ID ) = {

	id = bound-tok-param ;

	{

		comma ; q = bound-tok-pars ;

	    ||	comma ; <error_comma> ; q = <list_id_null> ;

	    ||	q = <list_id_null> ;

	} ;

	p = <list_id_cons> ( id, q ) ;

} ;

prog-tok-param : ( r : LIST-ID ) -> ( id : IDENTIFIER ) = {

	exp-cap ; tid = any-identifier ;

	id = <token_exp_par> ( tid, r ) ;

    ||

	stmt-cap ; tid = any-identifier ;

	id = <token_stmt_par> ( tid, r ) ;

    ||

	type-cap ; t = <parse_type> ;

	id = <token_type_par> ( t, r ) ;

    ||

	member-cap ;

	t = <parse_type> ; colon ; tid = any-identifier ;

	id = <token_member_par> ( t, tid, r ) ;

    ||

	proc-cap ; tid = any-identifier ;

	id = <token_proc_par> ( tid, r ) ;

} ;

prog-tok-pars : ( r : LIST-ID ) -> ( p : LIST-ID ) = {

	a = prog-tok-param ( r ) ;

	{

		comma ; q = prog-tok-pars ( r ) ;

	    ||	comma ; <error_comma> ; q = <list_id_null> ;

	    ||	q = <list_id_null> ;

	} ;

	p = <list_id_cons> ( a, q ) ;

} ;

simple-tok-param : () -> ( id : IDENTIFIER ) = {

	tok = token-introduction ;

	t = tag-opt ;

	{

		tid = any-identifier ;

	    ||	tid = <id_anon> ;

	} ;

	id = <token_param> ( tok, t, tid ) ;

} ;

simple-tok-pars : () -> ( p : LIST-ID ) = {

	id = simple-tok-param ;

	{

		comma ; q = simple-tok-pars ;

	    ||	comma ; <error_comma> ; q = <list_id_null> ;

	    ||	q = <list_id_null> ;

	} ;

	p = <list_id_cons> ( id, q ) ;

} ;

/*

    TOKEN SYNTAX

    These rules describe the '#pragma token' syntax.

*/

<rescan_id> : () -> () ;

<rescan_keyword> : () -> () ;

<rescan_tag_line> : () -> () ;

<token_nat> : () -> ( :TOKEN ) ;

<token_snat> : () -> ( :TOKEN ) ;

<token_stmt> : () -> ( :TOKEN ) ;

<token_type> : () -> ( :TOKEN ) ;

<token_variety> : () -> ( :TOKEN ) ;

<token_signed> : () -> ( :TOKEN ) ;

<token_unsigned> : () -> ( :TOKEN ) ;

<token_float> : () -> ( :TOKEN ) ;

<token_arith> : () -> ( :TOKEN ) ;

<token_class> : () -> ( :TOKEN ) ;

<token_scalar> : () -> ( :TOKEN ) ;

<token_struct> : () -> ( :TOKEN ) ;

<token_union> : () -> ( :TOKEN ) ;

<token_exp> : ( :BOOL, :BOOL, :TYPE ) -> ( :TOKEN ) ;

<token_member> : ( :ACCESS, :TYPE, :TYPE ) -> ( :TOKEN ) ;

<token_func> : ( :TYPE ) -> ( :TOKEN ) ;

<token_proc_begin> : () -> ( :TOKEN ) ;

<token_proc_simple> : ( :TOKEN, :LIST-ID ) -> ( :TOKEN ) ;

<token_proc_complex> : ( :TOKEN, :LIST-ID, :LIST-ID ) -> ( :TOKEN ) ;

<token_proc_end> : ( :TOKEN, :TOKEN ) -> ( :TOKEN ) ;

<token_decl> : ( :TOKEN, :BOOL, :IDENTIFIER, :IDENTIFIER ) -> () ;

<is_operator> : () -> ( :BOOL ) ;

<parse_operator> : () -> ( :IDENTIFIER ) ;

<access_private> : () -> ( :ACCESS ) ;

<access_protected> : () -> ( :ACCESS ) ;

<access_public> : () -> ( :ACCESS ) ;

exp-storage : () -> ( b : BOOL, c : BOOL ) = {

	lvalue ; b = <bool_true> ; c = <bool_false> ;

    ||	rvalue ; b = <bool_false> ; c = <bool_false> ;

    ||	const ; b = <bool_false> ; c = <bool_true> ;

    ||	b = <bool_false> ; c = <bool_false> ;

} ;

access-specifier-opt : () -> ( a : ACCESS ) = {

	private ; a = <access_private> ;

    ||	protected ; a = <access_protected> ;

    ||	public ; a = <access_public> ;

    ||	a = <access_public> ;

} ;

token-introduction : () -> ( tok : TOKEN ) = {

	nat-cap ;

	tok = <token_nat> ;

    ||

	int-cap ;

	tok = <token_snat> ;

    ||

	stmt-cap ;

	tok = <token_stmt> ;

    ||

	type-cap ;

	tok = <token_type> ;

    ||

	variety-cap ;

	tok = <token_variety> ;

    ||

	variety-cap ; signed ;

	tok = <token_signed> ;

    ||

	variety-cap ; unsigned ;

	tok = <token_unsigned> ;

    ||

	float-cap ;

	tok = <token_float> ;

    ||

	arith-cap ;

	tok = <token_arith> ;

    ||

	class-cap ;

	tok = <token_class> ;

    ||

	scalar-cap ;

	tok = <token_scalar> ;

    ||

	struct-cap ;

	tok = <token_struct> ;

    ||

	union-cap ;

	tok = <token_union> ;

    ||

	exp-cap ; ( b, c ) = exp-storage ; colon ;

	t = <parse_type> ; colon ;

	tok = <token_exp> ( b, c, t ) ;

    ||

	member-cap ; a = access-specifier-opt ;

	t = <parse_mem_type> ; colon ; s = <parse_type> ; colon ;

	tok = <token_member> ( a, t, s ) ;

    ||

	func-cap ; t = <parse_func_type> ; colon ;

	tok = <token_func> ( t ) ;

    ||

	proc-cap ; open-brace ;

	a = <token_proc_begin> ;

	{

		p0 = bound-tok-pars ;

	    ||	p0 = <list_id_null> ;

	} ;

	p = p0 ;

	or ;

	{

		q0 = prog-tok-pars ( p ) ;

	    ||	q0 = <list_id_null> ;

	} ;

	q = q0 ;

	close-brace ;

	b = <token_proc_complex> ( a, p, q ) ;

	r = token-introduction ;

	tok = <token_proc_end> ( b, r ) ;

    ||

	proc-cap ; open-round ;

	a = <token_proc_begin> ;

	{

		p = simple-tok-pars ;

	    ||	p = <list_id_null> ;

	} ;

	close-round ;

	b = <token_proc_simple> ( a, p ) ;

	r = token-introduction ;

	tok = <token_proc_end> ( b, r ) ;

} ;

token-rule : () -> () = {

	token ; tok = token-introduction ;

	<rescan_tag_line> ;

	{

		t = tag-opt ; <rescan_id> ; a = any-identifier ;

	    ||

		? = <is_operator> ;

		a = <parse_operator> ; t = <bool_false> ;

	} ;

	hash ; <rescan_id> ;

	{

		b = any-identifier ;

	    ||	minus ; b = <id_anon> ;

	    ||	b = a ;

	} ;

	<token_decl> ( tok, t, a, b ) ;

} ;

/*

    TOKEN INTERFACE LISTS

    These rules are concerned with the '#pragma interface' statements.

*/

<token_name> : ( :IDENTIFIER ) -> ( :IDENTIFIER ) ;

<token_tag> : ( :IDENTIFIER ) -> ( :IDENTIFIER ) ;

<token_selector> : ( :IDENTIFIER, :IDENTIFIER ) -> ( :IDENTIFIER ) ;

<token_extern> : ( :IDENTIFIER ) -> ( :IDENTIFIER ) ;

<token_interface> : ( :IDENTIFIER, :LEX ) -> () ;

<interface_define> : () -> ( :LEX ) ;

<interface_no_def> : () -> ( :LEX ) ;

<interface_ignore> : () -> ( :LEX ) ;

<interface_crt> : () -> ( :LEX ) ;

<interface_undef> : () -> ( :LEX ) ;

token-id : () -> ( id : IDENTIFIER ) = {

	nm = any-identifier ;

	id = <token_name> ( nm ) ;

    ||

	tag-cap ; <rescan_id> ; nm = any-identifier ;

	id = <token_tag> ( nm ) ;

    ||

	? = <is_operator> ;

	nm = <parse_operator> ;

	id = <token_name> ( nm ) ;

    ||

	nm = token-id ; dot ; <rescan_id> ; mem = any-identifier ;

	id = <token_selector> ( nm, mem ) ;

    ||

	hash ; <rescan_id> ; nm = any-identifier ;

	id = <token_extern> ( nm ) ;

} ;

token-id-list : ( i : LEX ) -> () = {

	id = token-id ;

	<token_interface> ( id, i ) ;

	<rescan_tag_line> ;

	{

		token-id-list ( i ) ;

	    ||	$ ;

	} ;

} ;

interface-command : () -> ( i : LEX ) = {

	define ; i = <interface_define> ;

    ||	no-def ; i = <interface_no_def> ;

    ||	reject ; i = <interface_ignore> ;

    ||	interface ; i = <interface_crt> ;

    ||	undef ; token ; i = <interface_undef> ;

} ;

interface-rule : () -> () = {

	i = interface-command ;

	<rescan_tag_line> ;

	{

		token-id-list ( i ) ;

	    ||	$ ;

	} ;

} ;

/*

    TOKEN DEFINITION PRAGMAS

    These rules are concerned with those '#pragma' statements which are

    concerned with token definitions.

*/

<tokdef_start> : () -> () ;

<tokdef_end> : () -> () ;

<token_member_def> : ( :TYPE, :IDENTIFIER ) -> () ;

tokdef-rule : () -> () = {

	<tokdef_start> ;

	member ; definition ;

	t = <parse_type> ; colon ; id = any-identifier ;

	<tokdef_end> ;

	<token_member_def> ( t, id ) ;

} ;

/*

    IDENTIFIER PRAGMAS

    These rules are concerned with those '#pragma' statements which are

    concerned with special identifiers.

*/

<rescan_line> : () -> () ;

<rescan_allow_line> : () -> () ;

<rescan_as_line> : () -> () ;

<id_conv> : ( :IDENTIFIER ) -> () ;

<id_init> : ( :IDENTIFIER ) -> () ;

<id_postpone> : ( :IDENTIFIER, :LEX ) -> () ;

<id_preserve> : ( :IDENTIFIER ) -> () ;

<id_preserve_all> : () -> () ;

<id_susp> : ( :IDENTIFIER ) -> () ;

<lex_postpone> : () -> ( :LEX ) ;

<lex_unpostpone> : () -> ( :LEX ) ;

conversion-list : () -> () = {

	id = any-identifier ;

	<id_conv> ( id ) ;

	conversion-list ;

    ||

	$ ;

} ;

postpone-list : ( a : LEX ) -> () = {

	id = any-identifier ;

	<id_postpone> ( id, a ) ;

	postpone-list ( a ) ;

    ||

	$ ;

} ;

preserve-list : () -> () = {

	id = any-identifier ;

	<id_preserve> ( id ) ;

	preserve-list ;

    ||

	$ ;

} ;

suspend-list : () -> () = {

	id = any-identifier ;

	<id_susp> ( id ) ;

	suspend-list ;

    ||

	$ ;

} ;

identifier-rule : () -> () = {

	accept ; conversion ; <rescan_line> ; conversion-list ;

    ||

	conversion ; <rescan_allow_line> ; conversion-list ; allow ;

    ||

	initialization ; <rescan_id> ; id = any-identifier ; allow ;

	<id_init> ( id ) ;

    ||

	postpone ; <rescan_line> ;

	a = <lex_postpone> ; postpone-list ( a ) ;

    ||

	preserve ; <rescan_line> ; preserve-list ;

    ||

	preserve ; star ;

	<id_preserve_all> ;

    ||

	suspend ; static ; <rescan_line> ; suspend-list ;

    ||

	unpostpone ; <rescan_line> ;

	a = <lex_unpostpone> ; postpone-list ( a ) ;

} ;

/*

    ERROR STATES

    These give the various error states which may be associated with an

    option.

*/

<error_on> : () -> ( :STATE ) ;

<error_off> : () -> ( :STATE ) ;

<error_warning> : () -> ( :STATE ) ;

<opt_on> : () -> ( :NUMBER ) ;

<opt_off> : () -> ( :NUMBER ) ;

<opt_warning> : () -> ( :NUMBER ) ;

error-state : () -> ( e : STATE ) = {

	on ; e = <error_on> ;

    ||	off ; e = <error_off> ;

    ||	warning ; e = <error_warning> ;

} ;

allow-state : () -> ( e : STATE ) = {

	allow ; e = <error_off> ;

    ||	disallow ; e = <error_on> ;

    ||	warning ; e = <error_warning> ;

} ;

option-state : () -> ( e : STATE ) = {

	on ; e = <error_on> ;

    ||	off ; e = <error_off> ;

    ||	allow ; e = <error_off> ;

    ||	disallow ; e = <error_on> ;

    ||	warning ; e = <error_warning> ;

} ;

warning-opt : () -> ( e : STATE ) = {

	warning ; e = <error_warning> ;

    ||	e = <error_on> ;

} ;

error-severity : () -> ( e : NUMBER ) = {

	on ; e = <opt_on> ;

    ||	off ; e = <opt_off> ;

    ||	allow ; e = <opt_off> ;

    ||	disallow ; e = <opt_on> ;

    ||	warning ; e = <opt_warning> ;

} ;

/*

    INTEGER LITERAL PRAGMAS

    These rules are concerned with those '#pragma' statements which are

    used to specify integer literal types.

*/

<base_octal> : () -> ( :NUMBER ) ;

<base_decimal> : () -> ( :NUMBER ) ;

<base_hexadecimal> : () -> ( :NUMBER ) ;

<suffix_none> : () -> ( :NUMBER ) ;

<suffix_u> : () -> ( :NUMBER ) ;

<suffix_l> : () -> ( :NUMBER ) ;

<suffix_ul> : () -> ( :NUMBER ) ;

<suffix_ll> : () -> ( :NUMBER ) ;

<suffix_ull> : () -> ( :NUMBER ) ;

<literal_set> : () -> () ;

<literal_begin> : ( :NUMBER, :NUMBER ) -> () ;

<literal_type> : ( :TYPE ) -> () ;

<literal_token> : ( :IDENTIFIER, :STATE ) -> () ;

<literal_star> : ( :STATE ) -> () ;

<literal_infinity> : () -> () ;

<literal_integer> : ( :EXP ) -> () ;

<literal_range> : () -> () ;

literal-base : () -> ( b : NUMBER ) = {

	octal ; b = <base_octal> ;

    ||	decimal ; b = <base_decimal> ;

    ||	hexadecimal ; b = <base_hexadecimal> ;

} ;

literal-suffix : () -> ( s : NUMBER ) = {

	s = <suffix_none> ;

    ||	unsigned ; s = <suffix_u> ;

    ||	long ; s = <suffix_l> ;

    ||	unsigned ; long ; s = <suffix_ul> ;

    ||	long ; long ; s = <suffix_ll> ;

    ||	unsigned ; long ; long ; s = <suffix_ull> ;

} ;

literal-item : () -> () = {

	colon ; t = <parse_type> ;

	<literal_type> ( t ) ;

    ||

	star ; <rescan_keyword> ;

	{

		a = allow-state ;

	    ||	a = <error_off> ;

	} ;

	colon ; <rescan_id> ; id = any-identifier ;

	<literal_token> ( id, a ) ;

    ||

	star ; star ; <rescan_keyword> ;

	{

		a = allow-state ;

	    ||	a = <error_on> ;

	} ;

	colon ;

	<literal_star> ( a ) ;

} ;

literal-item-list : () -> () = {

	e = integer-literal ; <literal_integer> ( e ) ;

	literal-item ; or ; literal-item-list ;

    ||

	question ; <literal_range> ;

	literal-item ; or ; literal-item-list ;

    ||

	star ; <literal_infinity> ;

	literal-item ;

} ;

literal-rule : () -> () = {

	integer ; lit ;

	<literal_set> ;

	b = literal-base ; s = literal-suffix ;

	<literal_begin> ( b, s ) ;

	<rescan_line> ;

	literal-item-list ;

} ;

/*

    KEYWORD PRAGMAS

    These rules are concerned with those '#pragma' statements which are

    used to introduce new keywords.

*/

<lex_asm> : () -> ( :LEX ) ;

<lex_discard> : () -> ( :LEX ) ;

<lex_exhaustive> : () -> ( :LEX ) ;

<lex_fall> : () -> ( :LEX ) ;

<lex_inline> : () -> ( :LEX ) ;

<lex_reachable> : () -> ( :LEX ) ;

<lex_representation> : () -> ( :LEX ) ;

<lex_set> : () -> ( :LEX ) ;

<lex_unreachable> : () -> ( :LEX ) ;

<lex_unused> : () -> ( :LEX ) ;

<lex_weak> : () -> ( :LEX ) ;

<lex_symbol> : () -> ( :LEX ) ;

<keyword_spec> : ( :IDENTIFIER ) -> ( :LEX ) ;

<keyword_define> : ( :IDENTIFIER, :LEX ) -> () ;

<keyword_undef> : ( :IDENTIFIER ) -> () ;

keyword-id : () -> ( id : IDENTIFIER ) = {

	keyword ; <rescan_id> ; id = any-identifier ;

} ;

keyword-spec : () -> ( t : LEX ) = {

	asm ; t = <lex_asm> ;

    ||	discard ; value ; t = <lex_discard> ;

    ||	discard ; variable ; t = <lex_unused> ;

    ||	exhaustive ; t = <lex_exhaustive> ;

    ||	fall ; into ; case ; t = <lex_fall> ;

    ||	inline ; t = <lex_inline> ;

    ||	set ; t = <lex_set> ;

    ||	set ; reachable ; t = <lex_reachable> ;

    ||	set ; unreachable ; t = <lex_unreachable> ;

    ||	type ; representation ; t = <lex_representation> ;

    ||	weak ; t = <lex_weak> ;

    ||	id = keyword-id ; t = <keyword_spec> ( id ) ;

    ||	operator ; t = <lex_symbol> ; plus ;

} ;

keyword-rule : () -> () = {

	id = keyword-id ; for ; t = keyword-spec ;

	<keyword_define> ( id, t ) ;

    ||

	undef ; id = keyword-id ;

	<keyword_undef> ( id ) ;

} ;

/*

    TYPE PRAGMAS

    These rules are concerned with those '#pragma' statements which are

    used to introduce special types.

*/

<type_argument> : ( :TYPE, :TYPE ) -> () ;

<type_ellipsis> : ( :TYPE ) -> () ;

<type_char_sign> : ( :BTYPE ) -> () ;

<type_char_lit> : ( :TYPE ) -> () ;

<type_long_long> : ( :BOOL ) -> () ;

<type_string_lit> : ( :CV ) -> () ;

<type_compatible> : ( :TYPE, :TYPE, :STATE ) -> () ;

<type_compute> : ( :IDENTIFIER ) -> () ;

<type_promote> : ( :TYPE, :TYPE ) -> () ;

<type_builtin> : ( :BTYPE, :TYPE ) -> () ;

<type_special> : ( :IDENTIFIER, :TYPE ) -> () ;

<type_bottom> : () -> ( :TYPE ) ;

<type_printf> : () -> ( :TYPE ) ;

<type_scanf> : () -> ( :TYPE ) ;

<type_wprintf> : () -> ( :TYPE ) ;

<type_wscanf> : () -> ( :TYPE ) ;

<type_ptrdiff_t> : () -> ( :TYPE ) ;

<type_size_t> : () -> ( :TYPE ) ;

<type_wchar_t> : () -> ( :TYPE ) ;

<nspace_std> : ( :IDENTIFIER ) -> () ;

<id_none> : () -> ( :IDENTIFIER ) ;

<declarator_start> : () -> () ;

<btype_none> : () -> ( :BTYPE ) ;

<btype_signed> : () -> ( :BTYPE ) ;

<btype_unsigned> : () -> ( :BTYPE ) ;

<btype_ptrdiff_t> : () -> ( :BTYPE ) ;

<btype_size_t> : () -> ( :BTYPE ) ;

<btype_wchar_t> : () -> ( :BTYPE ) ;

<cv_none> : () -> ( :CV ) ;

<cv_const> : () -> ( :CV ) ;

type-spec : () -> () = {

	argument ; <rescan_as_line> ;

	t = <parse_type> ; as ; s = <parse_type> ;

	<type_argument> ( t, s ) ;

    ||

	argument ; <rescan_as_line> ;

	t = <parse_type> ; as ; ellipsis-aux ;

	<type_ellipsis> ( t ) ;

    ||

	bottom ; <rescan_id> ;

	<declarator_start> ;

	id = any-identifier ;

	t = <type_bottom> ;

	<type_special> ( id, t ) ;

    ||

	character ;

	{

		signed ; bt = <btype_signed> ;

	    ||	unsigned ; bt = <btype_unsigned> ;

	    ||	either ; bt = <btype_none> ;

	} ;

	<type_char_sign> ( bt ) ;

    ||

	compatible ; type ; colon ; <rescan_line> ;

	t = <parse_type> ; eq ; s = <parse_type> ; colon ;

	<rescan_keyword> ; e = allow-state ;

	<type_compatible> ( t, s, e ) ;

    ||

	compute ; promote ; <rescan_id> ;

	id = any-identifier ;

	<type_compute> ( id ) ;

    ||

	promoted ; <rescan_line> ;

	t = <parse_type> ; colon ; s = <parse_type> ;

	<type_promote> ( t, s ) ;

    ||

	set ;

	{

		ptrdiff-t ; bt = <btype_ptrdiff_t> ;

	    ||	size-t ; bt = <btype_size_t> ;

	    ||	wchar-t ; bt = <btype_wchar_t> ;

	} ;

	colon ; <rescan_line> ; t = <parse_type> ;

	<type_builtin> ( bt, t ) ;

    ||

	set ; character ; lit ;

	colon ; <rescan_line> ; t = <parse_type> ;

	<type_char_lit> ( t ) ;

    ||

	set ; longlong ; type ; colon ; long ;

	{

		long ; b = <bool_true> ;

	    ||	b = <bool_false> ;

	} ;

	<type_long_long> ( b ) ;

    ||

	set ; string ; lit ; colon ;

	{

		cv = <cv_const> ;

	    ||	no ; cv = <cv_none> ;

	} ;

	const ;

	<type_string_lit> ( cv ) ;

    ||

	set ; std ; namespace ; colon ; <rescan_id> ;

	{

		id = any-identifier ;

	    ||	colon-colon ; id = <id_none> ;

	} ;

	<nspace_std> ( id ) ;

    ||

	type ; <rescan_id> ;

	<declarator_start> ;

	id = any-identifier ; for ;

	{

		bottom ; t = <type_bottom> ;

	    ||	ellipsis-aux ; printf ; t = <type_printf> ;

	    ||	ellipsis-aux ; scanf ; t = <type_scanf> ;

	    ||	ellipsis-aux ; wchar-t ; printf ; t = <type_wprintf> ;

	    ||	ellipsis-aux ; wchar-t ; scanf ; t = <type_wscanf> ;

	    ||	ptrdiff-t ; t = <type_ptrdiff_t> ;

	    ||	size-t ; t = <type_size_t> ;

	    ||	wchar-t ; t = <type_wchar_t> ;

	} ;

	<type_special> ( id, t ) ;

} ;

/*

    OPTION DECLARATIONS

    Each option is associated with a numerical value.  These actions

    gives this mapping.

*/

<opt_bitf_overflow> : () -> ( :NUMBER ) ;

<opt_bitf_type> : () -> ( :NUMBER ) ;

<opt_bool_assign> : () -> ( :NUMBER ) ;

<opt_case_fall> : () -> ( :NUMBER ) ;

<opt_cast_explicit> : () -> ( :NUMBER ) ;

<opt_comma_extra> : () -> ( :NUMBER ) ;

<opt_complete_struct> : () -> ( :NUMBER ) ;

<opt_concat_string> : () -> ( :NUMBER ) ;

<opt_cond_lvalue> : () -> ( :NUMBER ) ;

<opt_const_cond> : () -> ( :NUMBER ) ;

<opt_const_internal> : () -> ( :NUMBER ) ;

<opt_const_string> : () -> ( :NUMBER ) ;

<opt_conv> : () -> ( :NUMBER ) ;

<opt_conv_int_enum> : () -> ( :NUMBER ) ;

<opt_conv_int_int> : () -> ( :NUMBER ) ;

<opt_conv_int_int_expl> : () -> ( :NUMBER ) ;

<opt_conv_int_int_impl> : () -> ( :NUMBER ) ;

<opt_conv_int_ptr> : () -> ( :NUMBER ) ;

<opt_conv_int_ptr_expl> : () -> ( :NUMBER ) ;

<opt_conv_int_ptr_impl> : () -> ( :NUMBER ) ;

<opt_conv_ptr_func> : () -> ( :NUMBER ) ;

<opt_conv_ptr_ptr> : () -> ( :NUMBER ) ;

<opt_conv_ptr_ptr_expl> : () -> ( :NUMBER ) ;

<opt_conv_ptr_ptr_impl> : () -> ( :NUMBER ) ;

<opt_conv_ptr_ptr_void> : () -> ( :NUMBER ) ;

<opt_conv_ptr_void_ptr> : () -> ( :NUMBER ) ;

<opt_decl_cond> : () -> ( :NUMBER ) ;

<opt_decl_hide> : () -> ( :NUMBER ) ;

<opt_decl_none> : () -> ( :NUMBER ) ;

<opt_decl_struct_anon> : () -> ( :NUMBER ) ;

<opt_decl_unify> : () -> ( :NUMBER ) ;

<opt_decl_volatile> : () -> ( :NUMBER ) ;

<opt_discard> : () -> ( :NUMBER ) ;

<opt_discard_func> : () -> ( :NUMBER ) ;

<opt_discard_static> : () -> ( :NUMBER ) ;

<opt_discard_value> : () -> ( :NUMBER ) ;

<opt_dollar_ident> : () -> ( :NUMBER ) ;

<opt_dspec_none> : () -> ( :NUMBER ) ;

<opt_dspec_none_func> : () -> ( :NUMBER ) ;

<opt_ellipsis_extra> : () -> ( :NUMBER ) ;

<opt_ellipsis_ident> : () -> ( :NUMBER ) ;