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.

*/

/*

    C SYNTAX

    This module contains the syntax for the C language.

*/

/*

    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%

BOOL ;

BTYPE ;

CONDITION ;

COUNT ;

CV ;

DECL ;

DSPEC ;

EXP ;

IDENTIFIER ;

KEY ;

LEX ;

LIST-EXP ;

NAMESPACE ;

NUMBER ;

OFFSET ;

TYPE ;

/*

    LIST OF TERMINALS

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

    be automatically generated using the routine sid_terminals defined in

    debug.c (q.v).

*/

%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 ; } ;

close-square =	{ close-square-1 ; } ;

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

open-square =	{ open-square-1 ; } ;

and =		{ and-1 ; } ;

and-eq =	{ and-eq-1 ; } ;

compl =		{ compl-1 ; } ;

logical-and =	{ logical-and-1 ; } ;

logical-or =	{ logical-or-1 ; } ;

not =		{ not-1 ; } ;

not-eq =	{ not-eq-1 ; } ;

or =		{ or-1 ; } ;

or-eq =		{ or-eq-1 ; } ;

xor =		{ xor-1 ; } ;

xor-eq =	{ xor-eq-1 ; } ;

/*

    LEXICAL TOKENS

    These actions give the lexical token numbers for various symbols.

*/

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

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

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

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

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

/*

    EXPECTED SYMBOLS

    These rules are used when a certain symbol is expected.  If it is

    not present then the action expected is called with the appropriate

    lexical token number.

*/

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

<error_fatal> : () -> () ;

<error_syntax> : () -> () ;

open-round-x = {

	open-round ;

    ##	t = <lex_open_round> ; <expected> ( t ) ;

} ;

semicolon-x = {

	semicolon ;

    ##	t = <lex_semicolon> ; <expected> ( t ) ;

} ;

/*

    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.

*/

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

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

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

	id = identifier ;

    ||	id = type-name ;

    ||	id = statement-name ;

} ;

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

	id = any-identifier ;

    ||	id = <id_anon> ;

} ;

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

	id = any-identifier ;

    ##

	<error_syntax> ;

	id = <id_none> ;

} ;

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

	<error_syntax> ;

	id = <id_none> ;

} ;

/*

    LITERAL EXPRESSIONS

    These rules describe the literal expressions.  These are the integer

    and floating point literals and the character and string literals.

    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 ;

} ;

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

	e = floating-exp ;

} ;

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

	e = string-exp ;

    ||	e = wstring-exp ;

} ;

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

	e = integer-literal ;

    ||	e = character-literal ;

    ||	e = floating-literal ;

    ||	e = string-literal ;

} ;

/*

    PRIMARY EXPRESSIONS

    This rule describes the primary expressions.  These include the

    literals, the identity expressions, the this expression and the

    parenthesised expressions.  The assertion expressions are an

    extension.

*/

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

<exp_paren_begin> : () -> () ;

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

<exp_identifier> : ( :IDENTIFIER ) -> ( :EXP ) ;

expression : () -> ( :EXP ) ;

primary-expression : () -> ( e : EXP ) = {

	e = literal ;

    ||

	id = identifier ;

	e = <exp_identifier> ( id ) ;

    ||

	ellipsis-exp ;

	e = <exp_ellipsis> ;

    ||

	open-round ;

	<exp_paren_begin> ;

	a = expression ;

	e = <exp_paren_end> ( a ) ;

	close-round ;

    ||

	e = complex-exp ;

} ;

/*

    EXPRESSION LISTS

    These rules describes the lists of expressions.  Note that the

    constituents are assignment-expressions so that any commas are list

    separators rather than comma operators.

*/

<list_exp_null> : () -> ( :LIST-EXP ) ;

<list_exp_cons> : ( :EXP, :LIST-EXP ) -> ( :LIST-EXP ) ;

assignment-expression : () -> ( :EXP ) ;

expression-list : () -> ( p : LIST-EXP ) = {

	e = assignment-expression ;

	{

		comma ; q = expression-list ;

	    ||	q = <list_exp_null> ;

	} ;

	p = <list_exp_cons> ( e, q ) ;

} ;

expression-list-opt : () -> ( p : LIST-EXP ) = {

	p = expression-list ;

    ||	p = <list_exp_null> ;

} ;

/*

    FIELD SELECTOR EXPRESSIONS

    These rules are used to perform field selector look-up following a

    '.' or '->' operator.  The input namespace gives the class being

    selected from (or the null namespace in case of an error).  Note

    the provisions for dummy destructor calls.

*/

<rescan_member> : ( :NAMESPACE, :IDENTIFIER ) -> ( :IDENTIFIER ) ;

field-id-expression : ( ns : NAMESPACE ) -> ( id : IDENTIFIER ) = {

	uid = any-identifier ;

	id = <rescan_member> ( ns, uid ) ;

} ;

/*

    POSTFIX EXPRESSIONS

    These rules describes the postfix expressions.  These include array

    indexing, function calls and function style casts, field selectors,

    postfix increment and decrement operations, new style casts and

    type identification operators.

*/

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

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

<exp_index> : ( :EXP, :EXP ) -> ( :EXP ) ;

<exp_func> : ( :EXP, :LIST-EXP ) -> ( :EXP ) ;

<exp_dot_begin> : ( :EXP ) -> ( :EXP, :TYPE, :NAMESPACE ) ;

<exp_dot_end> : ( :EXP, :TYPE, :NAMESPACE, :IDENTIFIER ) -> ( :EXP ) ;

<exp_arrow_begin> : ( :EXP ) -> ( :EXP, :TYPE, :NAMESPACE ) ;

<exp_arrow_end> : ( :EXP, :TYPE, :NAMESPACE, :IDENTIFIER ) -> ( :EXP ) ;

<rescan_token> : () -> () ;

<no_type_defns> : () -> ( :COUNT ) ;

<no_side_effects> : () -> ( :COUNT ) ;

<diff_type_defns> : ( :COUNT ) -> ( :COUNT ) ;

<diff_side_effects> : ( :COUNT ) -> ( :COUNT ) ;

<sizeof_begin> : () -> () ;

<sizeof_end> : () -> () ;

type-id : () -> ( :TYPE, :COUNT ) ;

type-id-false : () -> ( :TYPE, :COUNT ) ;

type-id-true : () -> ( :TYPE, :COUNT ) ;

postfix-expression : () -> ( e : EXP ) = {

	e = primary-expression ;

    ||

	a = postfix-expression ;

	open-square ; b = expression ; close-square ;

	e = <exp_index> ( a, b ) ;

    ||

	a = postfix-expression ;

	open-round ; p = expression-list-opt ;

	e = <exp_func> ( a, p ) ;

	close-round ;

    ||

	a = postfix-expression ;

	( b, t, ns ) = <exp_dot_begin> ( a ) ;

	dot ; id = field-id-expression ( ns ) ;

	e = <exp_dot_end> ( b, t, ns, id ) ;

	<rescan_token> ;

    ||

	a = postfix-expression ;

	( b, t, ns ) = <exp_arrow_begin> ( a ) ;

	arrow ; id = field-id-expression ( ns ) ;

	e = <exp_arrow_end> ( b, t, ns, id ) ;

	<rescan_token> ;

    ||

	a = postfix-expression ; plus-plus ;

	e = <exp_postinc> ( a ) ;

    ||

	a = postfix-expression ; minus-minus ;

	e = <exp_postdec> ( a ) ;

} ;

/*

    UNARY EXPRESSIONS

    These rules describe the unary expressions.  These include the simple

    unary operations (indirection, address, unary plus, unary minus, logical

    negation and bitwise complement), the prefix increment and decrement

    operations and sizeof expressions, as well as the new and delete

    expressions.

*/

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

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

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

<exp_unary> : ( :LEX, :EXP ) -> ( :EXP ) ;

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

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

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

<exp_sizeof> : ( :LEX, :TYPE, :EXP, :COUNT ) -> ( :EXP ) ;

<type_of> : ( :LEX, :EXP, :COUNT ) -> ( :TYPE ) ;

unary-expression : () -> ( :EXP ) ;

cast-expression : () -> ( :EXP ) ;

sizeof-expression : ( op : LEX ) -> ( e : EXP ) = {

	<sizeof_begin> ;

	n1 = <no_side_effects> ;

	m1 = <no_type_defns> ;

	{

		a = unary-expression ;

		n2 = <diff_side_effects> ( n1 ) ;

		m2 = <diff_type_defns> ( m1 ) ;

		t = <type_of> ( op, a, n2 ) ;

		c = <exp_sizeof> ( op, t, a, m2 ) ;

	    ||

		open-round ; ( t, m2 ) = type-id-true ;

		a = <exp_none> ;

		c = <exp_sizeof> ( op, t, a, m2 ) ;

		close-round ;

	} ;

	<sizeof_end> ;

	e = c ;

} ;

unary-operator : () -> () = {

	plus ;

    ||	minus ;

    ||	compl ;

    ||	abs ;

} ;

unary-expression : () -> ( e : EXP ) = {

	e = postfix-expression ;

    ||

	plus-plus ; a = unary-expression ;

	e = <exp_preinc> ( a ) ;

    ||

	minus-minus ; a = unary-expression ;

	e = <exp_predec> ( a ) ;

    ||

	star ; a = cast-expression ;

	e = <exp_indir> ( a )  ;

    ||

	and ; a = cast-expression ;

	e = <exp_ref> ( a )  ;

    ||

	not ; a = cast-expression ;

	e = <exp_not> ( a ) ;

    ||

	op = <lex_crt> ; unary-operator ;

	a = cast-expression ;

	e = <exp_unary> ( op, a ) ;

    ||

	sizeof ; op = <lex_sizeof> ; e = sizeof-expression ( op ) ;

    ||

	alignof ; op = <lex_alignof> ; e = sizeof-expression ( op ) ;

} ;

/*

    CAST EXPRESSIONS

    This rule describes the traditional style cast expressions, consisting

    of a bracketed type identifier followed by an expression.  The ignore

    keyword is an extension which is semantically equivalent to casting

    to void.

*/

<exp_cast> : ( :TYPE, :EXP, :COUNT ) -> ( :EXP ) ;

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

cast-expression : () -> ( e : EXP ) = {

	e = unary-expression ;

    ||

	open-round ; ( t, n ) = type-id-false ; close-round ;

	a = cast-expression ;

	e = <exp_cast> ( t, a, n ) ;

    ||

	discard ; a = cast-expression ;

	e = <exp_ignore> ( a ) ;

} ;

/*

    MULTIPLICATIVE EXPRESSIONS

    This rule describes the multiplicative expressions.  These include

    the division and remainder operations, as well as multiplication.

*/

<exp_div> : ( :EXP, :EXP ) -> ( :EXP ) ;

<exp_rem> : ( :EXP, :EXP ) -> ( :EXP ) ;

<exp_mult> : ( :EXP, :EXP ) -> ( :EXP ) ;

multiplicative-expression : () -> ( e : EXP ) = {

	e = cast-expression ;

    ||

	a = multiplicative-expression ; star ; b = cast-expression ;

	e = <exp_mult> ( a, b ) ;

    ||

	a = multiplicative-expression ; div ; b = cast-expression ;

	e = <exp_div> ( a, b ) ;

    ||

	a = multiplicative-expression ; rem ; b = cast-expression ;

	e = <exp_rem> ( a, b ) ;

} ;

/*

    ADDITIVE EXPRESSIONS

    This rule describes the additive expressions.  These include both the

    addition and the subtraction operations.

*/

<exp_plus> : ( :EXP, :EXP ) -> ( :EXP ) ;

<exp_minus> : ( :EXP, :EXP ) -> ( :EXP ) ;

additive-expression : () -> ( e : EXP ) = {

	e = multiplicative-expression ;

    ||

	a = additive-expression ; plus ; b = multiplicative-expression ;

	e = <exp_plus> ( a, b ) ;

    ||

	a = additive-expression ; minus ; b = multiplicative-expression ;

	e = <exp_minus> ( a, b ) ;

} ;

/*

    SHIFT EXPRESSIONS

    This rule describes the shift expressions.  Both left and right shifts

    are included.

*/

<exp_lshift> : ( :EXP, :EXP ) -> ( :EXP ) ;

<exp_rshift> : ( :EXP, :EXP ) -> ( :EXP ) ;

shift-expression : () -> ( e : EXP ) = {

	e = additive-expression ;

    ||

	a = shift-expression ; lshift ; b = additive-expression ;

	e = <exp_lshift> ( a, b ) ;

    ||

	a = shift-expression ; rshift ; b = additive-expression ;

	e = <exp_rshift> ( a, b ) ;

} ;

/*

    RELATIONAL EXPRESSIONS

    These rules describe the relational expressions, less than, greater

    than, less than or equal and greater than or equal.

*/

<exp_relation> : ( :LEX, :EXP, :EXP ) -> ( :EXP ) ;

relational-operator : () -> () = {

	less ;

    ||	greater ;

    ||	less-eq ;

    ||	greater-eq ;

} ;

relational-expression : () -> ( e : EXP ) = {

	e = shift-expression ;

    ||

	a = relational-expression ;

	op = <lex_crt> ; relational-operator ;

	b = shift-expression ;

	e = <exp_relation> ( op, a, b ) ;

} ;

/*

    EQUALITY EXPRESSIONS

    These rules describe the equality expressions, equal and not equal.

*/

<exp_equality> : ( :LEX, :EXP, :EXP ) -> ( :EXP ) ;

equality-operator : () -> () = {

	eq ;

    ||	not-eq ;

} ;

equality-expression : () -> ( e : EXP ) = {

	e = relational-expression ;

    ||

	a = equality-expression ;

	op = <lex_crt> ; equality-operator ;

	b = relational-expression ;

	e = <exp_equality> ( op, a, b ) ;

} ;

/*

    MAXIMUM AND MINIMUM EXPRESSIONS (EXTENSION)

    These rules describes the maximum and minimum expressions.

*/

<exp_maxmin> : ( :LEX, :EXP, :EXP ) -> ( :EXP ) ;

maxmin-operator : () -> () = {

	max ;

    ||	min ;

} ;

maxmin-expression : () -> ( e : EXP ) = {

	e = equality-expression ;

    ||

	a = maxmin-expression ;

	op = <lex_crt> ; maxmin-operator ;

	b = equality-expression ;

	e = <exp_maxmin> ( op, a, b ) ;

} ;

/*

    AND EXPRESSIONS

    This rule describes the bitwise and expressions.

*/

<exp_and> : ( :EXP, :EXP ) -> ( :EXP ) ;

and-expression : () -> ( e : EXP ) = {

	e = maxmin-expression ;

    ||

	a = and-expression ; and ; b = maxmin-expression ;

	e = <exp_and> ( a, b ) ;

} ;

/*

    EXCLUSIVE OR EXPRESSIONS

    This rule describes the bitwise exclusive or expressions.

*/

<exp_xor> : ( :EXP, :EXP ) -> ( :EXP ) ;

exclusive-or-expression : () -> ( e : EXP ) = {

	e = and-expression ;

    ||

	a = exclusive-or-expression ; xor ; b = and-expression ;

	e = <exp_xor> ( a, b ) ;

} ;

/*

    INCLUSIVE OR EXPRESSIONS

    This rule describes the bitwise inclusive or expressions.

*/

<exp_or> : ( :EXP, :EXP ) -> ( :EXP ) ;

inclusive-or-expression : () -> ( e : EXP ) = {

	e = exclusive-or-expression ;

    ||

	a = inclusive-or-expression ; or ; b = exclusive-or-expression ;

	e = <exp_or> ( a, b ) ;

} ;

/*

    LOGICAL AND EXPRESSIONS

    This rule describes the logical and expressions.

*/

<exp_log_and> : ( :EXP, :EXP ) -> ( :EXP ) ;

logical-and-expression : () -> ( e : EXP ) = {

	e = inclusive-or-expression ;

    ||

	a = logical-and-expression ;

	logical-and ; b = inclusive-or-expression ;

	e = <exp_log_and> ( a, b ) ;

} ;

/*

    LOGICAL OR EXPRESSIONS

    This rule describes the logical or expressions.

*/

<exp_log_or> : ( :EXP, :EXP ) -> ( :EXP ) ;

logical-or-expression : () -> ( e : EXP ) = {

	e = logical-and-expression ;

    ||

	a = logical-or-expression ;

	logical-or ; b = logical-and-expression ;

	e = <exp_log_or> ( a, b ) ;

} ;

/*

    CONDITIONAL EXPRESSIONS

    This rule describes the conditional expressions, consisting of the

    '?:' operator.

*/

<exp_cond> : ( :EXP, :EXP, :EXP ) -> ( :EXP ) ;

conditional-expression : () -> ( e : EXP ) = {

	e = logical-or-expression ;

    ||

	c = logical-or-expression ;

	question ; a = expression ;

	colon ; b = conditional-expression ;

	e = <exp_cond> ( c, a, b ) ;

} ;

/*

    ASSIGNMENT EXPRESSIONS

    These rules describe the assignment expressions.  These include both

    simple assignment and the 'operate and becomes' operators like '+='.

*/

<exp_assign> : ( :EXP, :EXP ) -> ( :EXP ) ;

<exp_assign_op> : ( :LEX, :EXP, :EXP ) -> ( :EXP ) ;

assignment-operator : () -> () = {

	and-eq ;

    ||	div-eq ;

    ||	lshift-eq ;

    ||	minus-eq ;

    ||	or-eq ;

    ||	plus-eq ;

    ||	rem-eq ;

    ||	rshift-eq ;

    ||	star-eq ;

    ||	xor-eq ;

} ;

assignment-expression : () -> ( e : EXP ) = {

	e = conditional-expression ;

    ||

	a = unary-expression ;

	assign ; b = assignment-expression ;

	e = <exp_assign> ( a, b ) ;

    ||

	a = unary-expression ;

	op = <lex_crt> ; assignment-operator ;

	b = assignment-expression ;

	e = <exp_assign_op> ( op, a, b ) ;

} ;

expression-entry : () -> ( e : EXP ) = {

	e = assignment-expression ;

    ##

	<error_syntax> ;

	e = <exp_none> ;

} ;

/*

    FLOW ANALYSIS EXPRESSIONS (EXTENSION)

    This rule describes the flow analysis expressions, which are an

    extension to the standard syntax.  These consist of the assignment

    expressions, plus operations for setting and discarding values.

*/

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

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

flow-expression : () -> ( e : EXP ) = {

	set ; open-round ; a = expression ;

	e = <exp_set> ( a ) ;

	close-round ;

    ||

	unused ; open-round ; a = expression ;

	e = <exp_unused> ( a ) ;

	close-round ;

} ;

inset-flow-expression : () -> ( e : EXP ) = {

	inset-start ; set ; a = expression ;

	e = <exp_set> ( a ) ;

	inset-end ;

    ||

	inset-start ; unused ; a = expression ;

	e = <exp_unused> ( a ) ;

	inset-end ;

} ;

inset-flow-statement : () -> ( e : EXP ) = {

	inset-start ; set ; a = expression ;

	e = <exp_set> ( a ) ;

	semicolon ; inset-end ;

    ||

	inset-start ; unused ; a = expression ;

	e = <exp_unused> ( a ) ;

	semicolon ; inset-end ;

} ;

/*

    EXPRESSIONS

    This rule describes the top level expressions.  These are derived

    from the flow-expressions by the addition of the comma operator.

*/

<exp_comma> : ( :LIST-EXP ) -> ( :EXP ) ;

comma-expression-head : () -> ( e : EXP ) = {

	e = assignment-expression ; comma ;

    ||

	e = flow-expression ;

    ||

	e = inset-flow-expression ;

} ;

comma-expression-tail : () -> ( p : LIST-EXP ) = {

	a = assignment-expression ;

	q = <list_exp_null> ;

	p = <list_exp_cons> ( a, q ) ;

    ||

	a = comma-expression-head ; q = comma-expression-tail ;

	p = <list_exp_cons> ( a, q ) ;

} ;

expression : () -> ( e : EXP ) = {

	e = assignment-expression ;

    ||

	a = comma-expression-head ; q = comma-expression-tail ;

	p = <list_exp_cons> ( a, q ) ;

	e = <exp_comma> ( p ) ;

} ;

/*

    INITIALISER EXPRESSIONS

    An initialiser expression consists of an assignment expression

    with all its temporary variables bound to it.

*/

initialiser-expression : () -> ( e : EXP ) = {

	e = assignment-expression ;

} ;

/*

    CONSTANT EXPRESSIONS

    This rule describes the constant expressions.  Lexically these are

    identical to the conditional-expressions, but with restrictions on

    the permitted operands.  Constant expressions are identified by

    evaluation - whenever a valid constant expression is encountered it

    is evaluated to give an integer literal expression.

*/

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

constant-expression : () -> ( e : EXP ) = {

	a = conditional-expression ;

	e = <exp_eval> ( a ) ;

} ;

/*

    LABELLED STATEMENTS

    This rule describes the labelled statements.  These include the case

    and default statements as well as the simple labels.  Note that the

    statements following the labels are only the first component of the

    label body.  Actually imposing some structure on the labelled statements

    is the most difficult part of the statement processing.

*/

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

<stmt_case_end> : ( :EXP, :EXP ) -> ( :EXP ) ;

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

<stmt_default_end> : ( :EXP, :EXP ) -> ( :EXP ) ;

<stmt_label_begin> : ( :IDENTIFIER ) -> ( :EXP ) ;

<stmt_label_end> : ( :EXP, :EXP ) -> ( :EXP ) ;

<stmt_label_set> : () -> () ;

<stmt_label_mod> : () -> () ;

<stmt_label_clear> : () -> () ;

statement : () -> ( :EXP ) ;

fall-check : () -> () = {

	fall ; <stmt_label_set> ;

    ||	fall ; semicolon ; <stmt_label_set> ;

    ||	$ ;

} ;

labelled-statement : () -> ( e : EXP ) = {

	fall-check ;

	case ; c = constant-expression ;

	a = <stmt_case_begin> ( c ) ;

	<stmt_label_set> ;

	colon ; b = statement ;

	e = <stmt_case_end> ( a, b ) ;

    ||

	fall-check ;

	default ;

	a = <stmt_default_begin> ;

	<stmt_label_set> ;

	colon ; b = statement ;

	e = <stmt_default_end> ( a, b ) ;

    ||

	id = any-identifier ;

	<stmt_label_mod> ;

	a = <stmt_label_begin> ( id ) ;

	colon ; b = statement ;

	e = <stmt_label_end> ( a, b ) ;

} ;

/*

    EXPRESSION STATEMENTS

    This rule describes the expression statements, consisting of an optional

    expression followed by a semicolon.

*/