%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1997-2010. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%%
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%%
%% %CopyrightEnd%
%%
%%------------------------------------------------------------
%% Yecc spec for IDL
%%
%%
%%
%% Implementation Detail:
%% OorM_ means OneORMany and is used instead of
%% the "+" BNF notation
%% ZorM_ means ZeroORMany and is used instead of
%% the "*" BNF notation
%%
%% All the reverse/1 calls are because yecc+lists naturally leads
%% to reversed lists, which then have to be reversed. Maybe fix
%% this?
%%
%% Implementation history
%%
%% The IDL language supported is not the complete IDL. We skipped
%% the multiple declarator syntax allowed (i.e. typedef long T1,
%% T2). This also applies to attributes members in structs,
%% unions and exceptions, and to case labels in unions. The cases
%% where IDL has been altered is marked with comments containing
%% NIY.
%%
%% Above is chaging. Whenever we change a clause, we put (FIXED) in
%% its comment.
%%
%%------------------------------------------------------------
Nonterminals
'<op_type_spec>'
'<enumerator>'
'<switch_body>'
'OorM_<case>'
'<member_list>'
'<struct_type>'
'<unsigned_int>'
'<constr_type_spec>'
'<shift_expr>'
'<or_expr>'
'<inheritance_spec>'
'ZorM_<param_dcl>'
'Opt_<context_expr>'
'<attr_dcl>'
'<array_declarator>'
'<element_spec>'
'<signed_int>'
'<primary_expr>'
'<interface_dcl>'
'ZorM_<string_literal>'
'Opt_<raises_expr>'
'<integer_type>'
'<signed_long_int>'
'<literal>'
'<export>'
'<forward_dcl>'
'OorM_<definition>'
'<base_type_spec>'
'<op_dcl>'
'<const_exp>'
'<case>'
'<any_type>'
'<signed_short_int>'
'<unary_expr>'
'<context_expr>'
'ZorM_<scoped_name>'
'<switch_type_spec>'
'<complex_declarator>'
'<declarators>'
'OorM_<member>'
'<interface>'
'<parameter_dcls>'
'<op_attribute>'
'<positive_int_const>'
'OorM_<fixed_array_size>'
'<sequence_type>'
'<case_label>'
'<octet_type>'
'<type_dcl>'
'<module>'
'<specification>'
'<declarator>'
'<boolean_type>'
'<union_type>'
'<add_expr>'
'<interface_body>'
'<except_dcl>'
'<fixed_array_size>'
'<unsigned_short_int>'
'<boolean_literal>'
'<and_expr>'
'Opt_<inheritance_spec>'
'<scoped_name>'
'<param_type_spec>'
'ZorM_<member>'
'<char_type>'
'<const_dcl>'
'<param_dcl>'
'ZorM_<simple_declarator>'
'ZorM_<declarator>'
'<const_type>'
'<definition>'
'<param_attribute>'
'<simple_declarator>'
'Opt_readonly'
'<simple_type_spec>'
'<enum_type>'
'<type_spec>'
'OorM_<case_label>'
'<floating_pt_type>'
'<template_type_spec>'
'<mult_expr>'
'<xor_expr>'
'<string_type>'
'<raises_expr>'
'Opt_<op_attribute>'
'ZorM_<enumerator>'
'<member>'
'<unsigned_long_int>'
'<type_declarator>'
'<unary_operator>'
'ZorM_<export>'
'<interface_header>'
'OE_preproc' % NON standard
'OE_pragma' % NON standard
'Ugly_pragmas' % NON standard
'ZorM_<integer_literal>'
'<fixed_pt_type>'
'<fixed_pt_const_type>'
'<constr_forward_decl>'
.
Terminals
'#'
'in'
'['
'interface'
'('
'case'
'union'
'struct'
'<character_literal>'
'<wcharacter_literal>'
')'
']'
'any'
'long'
'float'
'out'
'*'
'^'
'enum'
'double'
'+'
'context'
'oneway'
'sequence'
','
'FALSE'
'<identifier>'
'{'
'readonly'
':'
'-'
'void'
';'
'char'
'wchar' %% WCHAR
'|'
'inout'
'}'
'attribute'
'<'
'octet'
'/'
'TRUE'
'~'
'='
'>'
'switch'
'unsigned'
'typedef'
'>>'
'const'
'<string_literal>'
'<wstring_literal>'
'raises'
'string'
'wstring'
'fixed'
'default'
'short'
'%'
'<<'
'module'
'exception'
'boolean'
'<integer_literal>'
'<fixed_pt_literal>'
'<floating_pt_literal>'
'&'
'::'
'Object'
.
Rootsymbol '<specification>'.
%%------------------------------------------------------------
%% Clauses
%%
%% Handling of pragmas.
%% Pragma prefix, id and version are not standard.
%% pragma prefix, or codeopt
OE_pragma -> '#' '<integer_literal>' '<identifier>'
'<identifier>' '<string_literal>' '#'
: #pragma{type='$4', to=followed, apply='$5'} .
%% pragma id
OE_pragma -> '#' '<integer_literal>' '<identifier>'
'<identifier>' '<identifier>' '<string_literal>' '#'
: #pragma{type='$4', to='$5', apply='$6'} .
%% pragma version
OE_pragma -> '#' '<integer_literal>' '<identifier>'
'<identifier>' '<identifier>' '<floating_pt_literal>' '#'
: #pragma{type='$4', to='$5', apply=ic_options:float_to_version('$6')} .
%% Ugly pragmas
Ugly_pragmas -> '$empty' : [].
Ugly_pragmas -> 'Ugly_pragmas' 'OE_pragma' : ['$2'|'$1'].
%% (0) Handling of preprocessor stuff.
OE_preproc -> '#' '#' .
OE_preproc -> '#' '<integer_literal>' '<string_literal>'
'ZorM_<integer_literal>' '#'
: case '$4' of
[] ->
case '$2' of
{_,_,"1"} ->
#preproc{cat=line_nr, id='$3', aux='$4'};
_ ->
[]
end;
_ ->
#preproc{cat=line_nr, id='$3', aux='$4'}
end.
%% (0b) Non-standard
'ZorM_<integer_literal>' -> '$empty' : [] .
'ZorM_<integer_literal>' -> '<integer_literal>' 'ZorM_<integer_literal>'
: ['$1' | '$2'] .
%% (1)
'<specification>' -> 'OorM_<definition>' : reverse('$1') .
%% Added clause
'OorM_<definition>' -> '<definition>' : ['$1'] .
'OorM_<definition>' -> 'OorM_<definition>' '<definition>'
: ['$2' | '$1'] .
%% (2)
'<definition>' -> '<type_dcl>' ';' : '$1' .
'<definition>' -> '<const_dcl>' ';' : '$1' .
'<definition>' -> '<except_dcl>' ';' : '$1' .
'<definition>' -> '<interface>' ';' : '$1' .
'<definition>' -> '<module>' ';' : '$1' .
'<definition>' -> 'OE_preproc' : '$1' .
'<definition>' -> 'OE_pragma' : '$1' .
%% (3)
'<module>' -> 'module' '<identifier>' '{' 'OorM_<definition>' '}'
: #module{ id='$2', body=reverse('$4')}.
%% (4)
'<interface>' -> '<interface_dcl>' : '$1' .
'<interface>' -> '<forward_dcl>' : '$1' .
%% (5)
'<interface_dcl>' -> '<interface_header>' '{' '<interface_body>' '}'
: #interface{id=element(1, '$1'), inherit=element(2, '$1'),
body=lists:reverse('$3')} .
%% (6)
'<forward_dcl>' -> 'interface' '<identifier>'
: #forward{id='$2'} .
%% (7)
'<interface_header>' -> 'interface' '<identifier>' 'Opt_<inheritance_spec>'
: {'$2', '$3'} .
%% (8)
'<interface_body>' -> 'ZorM_<export>' : '$1' .
%% Added clause
'ZorM_<export>' -> '$empty' : [] .
'ZorM_<export>' -> 'ZorM_<export>' '<export>'
%% Complicated because <export> might be a list (of type defs for instance)
: if is_list('$2') -> '$2' ++ '$1';
true -> ['$2' | '$1']
end .
%% (9)
'<export>' -> '<type_dcl>' ';' : '$1' .
'<export>' -> '<const_dcl>' ';' : '$1' .
'<export>' -> '<except_dcl>' ';' : '$1' .
'<export>' -> '<attr_dcl>' ';' : '$1' .
'<export>' -> '<op_dcl>' ';' : '$1' .
'<export>' -> 'OE_preproc' : '$1' .
'<export>' -> 'OE_pragma' : '$1' .
%% Added clause
'Opt_<inheritance_spec>' -> '$empty' : [].
'Opt_<inheritance_spec>' -> '<inheritance_spec>' : '$1'.
%% (10)
'<inheritance_spec>' -> ':' '<scoped_name>' 'ZorM_<scoped_name>'
: ['$2' | reverse('$3')] .
%% Added clause
'ZorM_<scoped_name>' -> '$empty' : [] .
'ZorM_<scoped_name>' -> 'ZorM_<scoped_name>' ',' '<scoped_name>'
: ['$3' | '$1'] .
%% (11)
'<scoped_name>' -> '<identifier>' : ic_symtab:scoped_id_new('$1') .
'<scoped_name>' -> '::' '<identifier>' : ic_symtab:scoped_id_new_global('$2') .
'<scoped_name>' -> '<scoped_name>' '::' '<identifier>'
: ic_symtab:scoped_id_add('$1', '$3') .
%% (12)
'<const_dcl>' -> 'const' '<const_type>' '<identifier>' '=' '<const_exp>'
: #const{type='$2', id='$3', val='$5'} .
%% (13)
'<const_type>' -> '<integer_type>' : '$1' .
'<const_type>' -> '<char_type>' : '$1' .
'<const_type>' -> '<boolean_type>' : '$1' .
'<const_type>' -> '<floating_pt_type>' : '$1' .
'<const_type>' -> '<string_type>' : '$1' .
'<const_type>' -> '<fixed_pt_const_type>' : '$1' .
'<const_type>' -> '<scoped_name>' : '$1' .
'<const_type>' -> '<octet_type>' : '$1' .
%% (14)
'<const_exp>' -> '<or_expr>' : '$1' .
%% (15)
'<or_expr>' -> '<xor_expr>' : '$1' .
'<or_expr>' -> '<or_expr>' '|' '<xor_expr>' : {'or', '$1', '$3'} .
%% (16)
'<xor_expr>' -> '<and_expr>' : '$1' .
'<xor_expr>' -> '<xor_expr>' '^' '<and_expr>' : {'xor', '$1', '$3'} .
%% (17)
'<and_expr>' -> '<shift_expr>' : '$1' .
'<and_expr>' -> '<and_expr>' '&' '<shift_expr>' : {'and', '$1', '$3'} .
%% (18)
'<shift_expr>' -> '<add_expr>' : '$1' .
'<shift_expr>' -> '<shift_expr>' '>>' '<add_expr>' : {'rshift', '$1', '$3'} .
'<shift_expr>' -> '<shift_expr>' '<<' '<add_expr>' : {'lshift', '$1', '$3'} .
%% (19)
'<add_expr>' -> '<mult_expr>' : '$1' .
'<add_expr>' -> '<add_expr>' '+' '<mult_expr>' : {'+', '$1', '$3'} .
'<add_expr>' -> '<add_expr>' '-' '<mult_expr>' : {'-', '$1', '$3'} .
%% (20)
'<mult_expr>' -> '<unary_expr>' : '$1' .
'<mult_expr>' -> '<mult_expr>' '*' '<unary_expr>' : {'*', '$1', '$3'} .
'<mult_expr>' -> '<mult_expr>' '/' '<unary_expr>' : {'/', '$1', '$3'} .
'<mult_expr>' -> '<mult_expr>' '%' '<unary_expr>' : {'%', '$1', '$3'} .
%% (21)
'<unary_expr>' -> '<unary_operator>' '<primary_expr>' : {'$1', '$2'} .
'<unary_expr>' -> '<primary_expr>' : '$1' .
%% (22)
'<unary_operator>' -> '-' : '$1' .
'<unary_operator>' -> '+' : '$1' .
'<unary_operator>' -> '~' : '$1' .
%% (23)
'<primary_expr>' -> '<scoped_name>' : '$1' .
'<primary_expr>' -> '<literal>' : '$1' .
'<primary_expr>' -> '(' '<const_exp>' ')' : '$2' .
%% (24)
'<literal>' -> '<integer_literal>' : '$1' .
'<literal>' -> '<wstring_literal>' : '$1' .
'<literal>' -> '<string_literal>' : '$1' .
'<literal>' -> '<character_literal>' : '$1' .
'<literal>' -> '<wcharacter_literal>' : '$1' .
'<literal>' -> '<fixed_pt_literal>' : '$1' .
'<literal>' -> '<floating_pt_literal>' : '$1' .
'<literal>' -> '<boolean_literal>' : '$1' .
%% (25)
'<boolean_literal>' -> 'TRUE' : '$1' .
'<boolean_literal>' -> 'FALSE' : '$1' .
%% (26)
'<positive_int_const>' -> '<const_exp>' : '$1' .
%% (27)
'<type_dcl>' -> 'typedef' '<type_declarator>' : '$2' .
'<type_dcl>' -> '<struct_type>' : '$1' .
'<type_dcl>' -> '<union_type>' : '$1' .
'<type_dcl>' -> '<enum_type>' : '$1' .
'<type_dcl>' -> '<constr_forward_decl>' : '$1' .
%% (28) NIY multiple declarators (FIXED)
'<type_declarator>' -> '<type_spec>' '<declarators>'
: #typedef{type='$1', id='$2'} . %%%ic:unfold(#typedef{type='$1', id='$2'}) .
%%'<type_declarator>' -> '<type_spec>' '<declarator>'
%% : #typedef{type='$1', id='$2'} .
%% (29)
'<type_spec>' -> '<simple_type_spec>' : '$1' .
'<type_spec>' -> '<constr_type_spec>' : '$1' .
%% (30)
'<simple_type_spec>' -> '<base_type_spec>' : '$1' .
'<simple_type_spec>' -> '<template_type_spec>' : '$1' .
'<simple_type_spec>' -> '<scoped_name>' : '$1' .
%% (31)
'<base_type_spec>' -> '<floating_pt_type>' : '$1' .
'<base_type_spec>' -> '<integer_type>' : '$1' .
'<base_type_spec>' -> '<char_type>' : '$1' .
'<base_type_spec>' -> '<boolean_type>' : '$1' .
'<base_type_spec>' -> '<octet_type>' : '$1' .
'<base_type_spec>' -> '<any_type>' : '$1' .
'<base_type_spec>' -> 'Object' : '$1' . %% NON Standard, isn't a base type
%% (32)
'<template_type_spec>' -> '<sequence_type>' : '$1' .
'<template_type_spec>' -> '<string_type>' : '$1' .
'<template_type_spec>' -> '<fixed_pt_type>' : '$1' .
%% (33)
'<constr_type_spec>' -> '<struct_type>' : '$1' .
'<constr_type_spec>' -> '<union_type>' : '$1' .
'<constr_type_spec>' -> '<enum_type>' : '$1' .
%% (34)
'<declarators>' -> '<declarator>' 'ZorM_<declarator>'
: ['$1' | reverse('$2')] .
%% Added clause
'ZorM_<declarator>' -> '$empty' : [] .
'ZorM_<declarator>' -> 'ZorM_<declarator>' ',' '<declarator>'
: ['$3' | '$1'] .
%% (35)
'<declarator>' -> '<simple_declarator>' : '$1' .
'<declarator>' -> '<complex_declarator>' : '$1' .
%% (36)
'<simple_declarator>' -> '<identifier>' : '$1' .
%% (37)
'<complex_declarator>' -> '<array_declarator>' : '$1' .
%% (38)
'<floating_pt_type>' -> 'float' : '$1' .
'<floating_pt_type>' -> 'double' : '$1' .
%% (39)
'<integer_type>' -> '<signed_int>' : '$1' .
'<integer_type>' -> '<unsigned_int>' : {'unsigned', '$1'} .
%% (40)
'<signed_int>' -> '<signed_long_int>' : '$1' .
'<signed_int>' -> '<signed_short_int>' : '$1' .
%% (41)
'<signed_long_int>' -> 'long' : '$1' .
'<signed_long_int>' -> 'long' 'long': {'long long', element(2,'$2')} .
%% (42)
'<signed_short_int>' -> 'short' : '$1' .
%% (43)
'<unsigned_int>' -> '<unsigned_long_int>' : '$1' .
'<unsigned_int>' -> '<unsigned_short_int>' : '$1' .
%% (44)
'<unsigned_long_int>' -> 'unsigned' 'long' : '$2' .
'<unsigned_long_int>' -> 'unsigned' 'long' 'long' : {'long long', element(2,'$2')} . %% ULLONG
%% (45)
'<unsigned_short_int>' -> 'unsigned' 'short' : '$2' .
%% (46)
'<char_type>' -> 'char' : '$1' .
'<char_type>' -> 'wchar' : '$1' . %% WCHAR
%% (47)
'<boolean_type>' -> 'boolean' : '$1' .
%% (48)
'<octet_type>' -> 'octet' : '$1' .
%% (49)
'<any_type>' -> 'any' : '$1' .
%%
'<fixed_pt_const_type>' -> 'fixed' : '$1'.
%% (50) NIY: unfolding of struct decls (FIXED)
%%'<struct_type>' -> 'struct' '<identifier>' '{' '<member_list>' '}'
%% : #struct{id='$2', body=ic:unfold('$4')} .
'<struct_type>' -> 'struct' '<identifier>' '{' '<member_list>' '}'
: #struct{id='$2', body='$4'} .
%% (51)
'<member_list>' -> 'OorM_<member>' : reverse('$1') .
%% Added clause
%%'OorM_<member>' -> '<member>' : ['$1'] .
%%'OorM_<member>' -> 'OorM_<member>' '<member>'
%% : ['$2' | '$1'] .
'OorM_<member>' -> '<member>' : '$1' .
'OorM_<member>' -> 'OorM_<member>' '<member>'
: '$2' ++ '$1' .
%% (52) NIY: member multiple declarators (FIXED)
%%'<member>' -> '<type_spec>' '<declarators>' ';'
%% : #member{type='$1', id='$2'} .
'<member>' -> 'Ugly_pragmas' '<type_spec>' '<declarators>' 'Ugly_pragmas' ';' 'Ugly_pragmas'
: '$1' ++ '$4' ++ '$6' ++ [#member{type='$2', id='$3'}] .
%% (53) NIY: unfolding of union cases (FIXED)
%%'<union_type>' -> 'union' '<identifier>' 'switch'
%% '(' '<switch_type_spec>' ')' '{' '<switch_body>' '}'
%% : #union{id='$2', type='$5', body=ic:unfold('$8')} .
'<union_type>' -> 'union' '<identifier>' 'switch'
'(' '<switch_type_spec>' ')' '{' '<switch_body>' '}'
: #union{id='$2', type='$5', body='$8'} .
%% (54)
'<switch_type_spec>' -> '<integer_type>' : '$1' .
'<switch_type_spec>' -> '<char_type>' : '$1' .
'<switch_type_spec>' -> '<boolean_type>' : '$1' .
'<switch_type_spec>' -> '<enum_type>' : '$1' .
'<switch_type_spec>' -> '<scoped_name>' : '$1' .
%% (55)
'<switch_body>' -> 'OorM_<case>' : reverse(lists:flatten('$1')) .
%%'<switch_body>' -> 'OorM_<case>' : '$1' .
%% Added clause
'OorM_<case>' -> '<case>' : ['$1'] .
'OorM_<case>' -> 'OorM_<case>' '<case>' : ['$2' | '$1'] .
%% (56) NIY thing: multiple case labels (FIXED)
%%'<case>' -> 'OorM_<case_label>' '<element_spec>' ';'
%% : '$2'#case_dcl{label=reverse('$1')} .
'<case>' ->
'Ugly_pragmas' 'OorM_<case_label>'
'Ugly_pragmas' '<element_spec>'
'Ugly_pragmas' ';' 'Ugly_pragmas'
: '$1' ++ '$3' ++ '$5' ++ '$7' ++ [ '$4'#case_dcl{label=reverse('$2')} ] .
%% Added clause
%%'OorM_<case_label>' -> '<case_label>' : ['$1'] .
%%'OorM_<case_label>' -> 'OorM_<case_label>' '<case_label>' : ['$2' | '$1'] .
'OorM_<case_label>' -> 'Ugly_pragmas' '<case_label>' 'Ugly_pragmas'
: '$1' ++ ['$2'] ++ '$3' .
'OorM_<case_label>' -> 'OorM_<case_label>' 'Ugly_pragmas' '<case_label>' 'Ugly_pragmas'
: '$2' ++ ['$3'|'$1'] ++ '$4'.
%% (57)
'<case_label>' -> 'case' '<const_exp>' ':' : '$2' .
'<case_label>' -> 'default' ':' : '$1' .
%% (58)
'<element_spec>' -> '<type_spec>' '<declarator>'
: #case_dcl{type='$1', id='$2'} .
%% (59)
%%'<enum_type>' -> 'enum' '<identifier>'
%%'{' '<enumerator>' 'ZorM_<enumerator>' '}'
%%: #enum{id='$2', body=['$4' | reverse('$5')]} .
'<enum_type>' -> 'enum' '<identifier>'
'{' 'Ugly_pragmas' '<enumerator>' 'Ugly_pragmas' 'ZorM_<enumerator>' 'Ugly_pragmas' '}'
: #enum{id='$2', body='$4'++'$6'++'$8'++['$5' | reverse('$7')]} .
%% Added clause
%%'ZorM_<enumerator>' -> '$empty' : [] .
%%'ZorM_<enumerator>' -> 'ZorM_<enumerator>' ',' '<enumerator>' : ['$3' | '$1'] .
'ZorM_<enumerator>' -> '$empty' : [] .
'ZorM_<enumerator>' -> 'ZorM_<enumerator>' 'Ugly_pragmas' ',' 'Ugly_pragmas' '<enumerator>'
: '$2'++'$4'++['$5' | '$1'] .
%% (60)
'<enumerator>' -> '<identifier>' : #enumerator{id='$1'} .
%% (61)
'<sequence_type>' -> 'sequence' '<' '<simple_type_spec>' ','
'<positive_int_const>' '>'
: #sequence{type='$3', length='$5'} .
'<sequence_type>' -> 'sequence' '<' '<simple_type_spec>' '>'
: #sequence{type='$3'} .
%% (62)
'<string_type>' -> 'string' '<' '<positive_int_const>' '>'
: #string{length='$3'} .
'<string_type>' -> 'string' : #string{} .
'<string_type>' -> 'wstring' '<' '<positive_int_const>' '>' %% WSTRING
: #wstring{length='$3'} .
'<string_type>' -> 'wstring' : #wstring{} . %% WSTRING
%% (63)
'<array_declarator>' -> '<identifier>' 'OorM_<fixed_array_size>'
: #array{id='$1', size=reverse('$2')} .
%% Added clause
'OorM_<fixed_array_size>' -> '<fixed_array_size>' : ['$1'] .
'OorM_<fixed_array_size>' -> 'OorM_<fixed_array_size>' '<fixed_array_size>'
: ['$2' | '$1'] .
%% (64)
'<fixed_array_size>' -> '[' '<positive_int_const>' ']' : '$2' .
%% (65) NIY: multiple attribute declarators (FIXED)
'<attr_dcl>' -> 'Opt_readonly' 'attribute' '<param_type_spec>'
'<simple_declarator>' 'ZorM_<simple_declarator>'
: #attr{readonly='$1', type='$3', id=['$4' | reverse('$5')]} .
%% : ic:unfold(#attr{readonly='$1', type='$3', id=['$4' | reverse('$5')]}) .
%%'<attr_dcl>' -> 'Opt_readonly' 'attribute' '<param_type_spec>'
%% '<simple_declarator>'
%% (66) NIY: unfolding of exception bodies (FIXED)
%%'<except_dcl>' -> 'exception' '<identifier>' '{' 'ZorM_<member>' '}'
%% : #except{id='$2', body=ic:unfold('$4')} .
'<except_dcl>' -> 'exception' '<identifier>' '{' 'ZorM_<member>' '}'
: #except{id='$2', body=reverse('$4')} .
%% (67)
'<op_dcl>' -> 'Opt_<op_attribute>' '<op_type_spec>' '<identifier>' '<parameter_dcls>' 'Opt_<raises_expr>' 'Opt_<context_expr>'
: #op{oneway='$1', type='$2', id='$3', params='$4', raises='$5', ctx='$6'} .
%% Added clause
'Opt_<op_attribute>' -> '$empty' : nil.
'Opt_<op_attribute>' -> '<op_attribute>' : '$1'.
%% (68)
'<op_attribute>' -> 'oneway' : '$1' .
%% (69)
'<op_type_spec>' -> '<param_type_spec>' : '$1' .
'<op_type_spec>' -> 'void' : '$1' .
%% (70) Rewritten
%'<parameter_dcls>' -> '(' '<param_dcl>' 'ZorM_<param_dcl>' ')'
% : ['$2' | reverse('$3')] .
%'<parameter_dcls>' -> '(' ')' : [] .
'<parameter_dcls>' -> '(' 'Ugly_pragmas' '<param_dcl>' 'ZorM_<param_dcl>' ')'
: '$2' ++ ['$3' | reverse('$4')] .
'<parameter_dcls>' -> '(' 'Ugly_pragmas' ')' : '$2' .
%% Added clause
%'ZorM_<param_dcl>' -> '$empty' : [] .
%'ZorM_<param_dcl>' -> 'ZorM_<param_dcl>' ',' '<param_dcl>' : ['$3' | '$1'] .
'ZorM_<param_dcl>' -> 'Ugly_pragmas' : '$1' .
'ZorM_<param_dcl>' -> 'ZorM_<param_dcl>' 'Ugly_pragmas' ',' 'Ugly_pragmas' '<param_dcl>' 'Ugly_pragmas'
: '$2' ++ '$4' ++ '$6' ++ ['$5' | '$1'] .
%% (71)
'<param_dcl>' -> '<param_attribute>' '<param_type_spec>' '<simple_declarator>'
: #param{inout='$1', type='$2', id='$3'} .
%% (72)
'<param_attribute>' -> 'in' : '$1' .
'<param_attribute>' -> 'out' : '$1' .
'<param_attribute>' -> 'inout' : '$1' .
%% Added clause
'Opt_<raises_expr>' -> '$empty' : [] .
'Opt_<raises_expr>' -> '<raises_expr>' : '$1' .
%% (73)
'<raises_expr>' -> 'raises' '(' '<scoped_name>' 'ZorM_<scoped_name>' ')'
: ['$3'| reverse('$4')] .
%% Added clause
'Opt_<context_expr>' -> '$empty' : [] .
'Opt_<context_expr>' -> '<context_expr>' : '$1'.
%% (74)
'<context_expr>' -> 'context' '(' '<string_literal>' 'ZorM_<string_literal>'')'
: ['$3' | reverse('$4')] .
%% (75)
'<param_type_spec>' -> '<base_type_spec>' : '$1' .
'<param_type_spec>' -> '<string_type>' : '$1' .
'<param_type_spec>' -> '<scoped_name>' : '$1' .
%% (96)
'<fixed_pt_type>' -> 'fixed' '<' '<positive_int_const>' ',' '<positive_int_const>' '>'
: #fixed{digits='$3',scale='$5'} .
%% (99)
'<constr_forward_decl>' -> 'struct' '<identifier>' : #constr_forward{id='$2', tk=tk_struct} .
'<constr_forward_decl>' -> 'union' '<identifier>' : #constr_forward{id='$2', tk=tk_union} .
%% Added clause
'ZorM_<string_literal>' -> '$empty' : [] .
'ZorM_<string_literal>' -> 'ZorM_<string_literal>' ',' '<string_literal>'
: ['$3' | '$1'] .
%% Added clause
'ZorM_<simple_declarator>' -> '$empty' : [] .
'ZorM_<simple_declarator>' -> 'ZorM_<simple_declarator>' ','
'<simple_declarator>' : ['$3' | '$1'] .
%% Added clause
%%'ZorM_<member>' -> '$empty' : [] .
%%'ZorM_<member>' -> 'ZorM_<member>' '<member>' : ['$2' | '$1'] .
'ZorM_<member>' -> 'Ugly_pragmas' : '$1' .
'ZorM_<member>' -> 'ZorM_<member>' '<member>' : '$2' ++ '$1' .
%% Added clause
'Opt_readonly' -> '$empty' : nil.
'Opt_readonly' -> 'readonly' : '$1'.
Erlang code.
%%-----------------------------------------------------------
