esyntax.yrl

OTP是开放电信平台的简称

%% ``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 via the world wide web 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.
%% 
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
%% AB. All Rights Reserved.''
%% 
%%     $Id$
%%
Nonterminals
add_op attribute basic_type bif_test
case_expr clause_body
clause_guard clause_head comp_op cr_clause cr_clauses expr expr_tail
exprs farity farity_list form formal_parameter_list function
function_call function_clause guard guard_call guard_expr
guard_expr_list guard_exprs guard_expr_tail guard_expr_tuple
guard_parameter_list
guard_tests guard_test if_clause if_clauses if_expr list match_expr
mult_op parameter_list pattern patterns pattern_list pattern_tail pattern_tuple
prefix_op receive_expr send_expr tuple.

Terminals
'!' '(' ')' '*' '+' ',' '-' '->' '/' '/=' ':' ';' '<' '=' '=/=' '=:='
'=<' '==' '>' '>=' '[' ']' 'after' 'band' 'begin' 'bnot'
'bor' 'bsl' 'bsr' 'bxor' 'case' 'catch' 'div' 'end' 'if' 'of'
'receive' 'rem' 'when' '{' '|' '}' atom float integer string var.
% 'receive' 'rem' 'true' 'when' '{' '|' '}' atom float integer string var.

Rootsymbol form.

Endsymbol dot.

Unary 0 'catch'.
Right 200 '='.
Right 200 '!'.
Left 300 add_op.
Left 400 mult_op.
Unary 500 prefix_op.


add_op -> '+' : '$1'.
add_op -> '-' : '$1'.
add_op -> 'bor' : '$1'.
add_op -> 'bxor' : '$1'.
add_op -> 'bsl' : '$1'.
add_op -> 'bsr' : '$1'.

comp_op -> '==' : '$1'.
comp_op -> '/=' : '$1'.
comp_op -> '=<' : '$1'.
comp_op -> '<' : '$1'.
comp_op -> '>=' : '$1'.
comp_op -> '>' : '$1'.
comp_op -> '=:=' : '$1'.
comp_op -> '=/=' : '$1'.

mult_op -> '*' : '$1'.
mult_op -> '/' : '$1'.
mult_op -> 'div' : '$1'.
mult_op -> 'rem' : '$1'.
mult_op -> 'band' : '$1'.

prefix_op -> '+' : '$1'.
prefix_op -> '-' : '$1'.
prefix_op -> 'bnot' : '$1'.


basic_type -> atom : '$1'.
basic_type -> float : '$1'.
basic_type -> integer : '$1'.
basic_type -> string : '$1'.
basic_type -> var : '$1'.
% basic_type -> 'true' : {atom, element(2, '$1'), 'true'}.


pattern -> basic_type : '$1'.
pattern -> pattern_list : '$1'.
pattern -> pattern_tuple : '$1'.

pattern_list -> '[' ']' : {nil, element(2, '$1')}.
pattern_list -> '[' pattern pattern_tail ']' :
   {cons, element(2, '$1'), '$2', '$3'}.

pattern_tail -> '|' pattern : '$2'.
pattern_tail -> ',' pattern pattern_tail :
   {cons, element(2, '$2'), '$2', '$3'}.
pattern_tail -> '$empty' : {nil, 0}.

pattern_tuple -> '{' '}' : {tuple, element(2, '$1'), []}.
pattern_tuple -> '{' patterns '}' : {tuple, element(2, '$1'), '$2'}.

patterns -> pattern : ['$1'].
patterns -> pattern ',' patterns : ['$1' | '$3'].


expr -> basic_type : '$1'.
expr -> list : '$1'.
expr -> tuple : '$1'.
expr -> function_call : '$1'.

expr -> expr add_op expr :
   {Op, Pos} = '$2',
   {arith, Pos, Op, '$1', '$3'}.
expr -> expr mult_op expr :
   {Op, Pos} = '$2',
   {arith, Pos, Op, '$1', '$3'}.
expr -> prefix_op expr:
   case '$2' of
       {float, Pos, N} ->
	   case '$1' of
	       {'-', _} ->
		   {float, Pos, -N};
	       {'+', _} ->
		   {float, Pos, N};
	       {Op, Pos1} ->
		   {arith, Pos1, Op, {float, Pos, N}}
	   end;
       {integer, Pos, N} ->
	   case '$1' of
	       {'-', _} ->
		   {integer, Pos, -N};
	       {'+', _} ->
		   {integer, Pos, N};
	       {Op, Pos1} ->
		   {arith, Pos1, Op, {integer, Pos, N}}
	   end;
       _ ->
	   {Op, Pos} = '$1',
	   {arith, Pos, Op, '$2'}
   end.

expr -> '(' expr ')' : '$2'.
expr -> 'begin' exprs 'end' : {block, element(2, '$1'), '$2'}.
expr -> 'catch' expr : {'catch', element(2, '$1'), '$2'}.

expr -> case_expr : '$1'.
expr -> if_expr : '$1'.
expr -> receive_expr : '$1'.
expr -> match_expr : '$1'.
expr -> send_expr : '$1'.


list -> '[' ']' : {nil, element(2, '$1')}.
list -> '[' expr expr_tail ']' : {cons, element(2, '$1'), '$2', '$3'}.

expr_tail -> '|' expr : '$2'.
expr_tail -> ',' expr expr_tail : {cons, element(2, '$2'), '$2', '$3'}.
expr_tail -> '$empty' : {nil, 0}.

tuple -> '{' '}' : {tuple, element(2, '$1'), []}.
tuple -> '{' exprs '}' : {tuple, element(2, '$1'), '$2'}.


function_call -> atom '(' parameter_list ')' :
   case erl_parse:erlang_bif(element(3, '$1'), length('$3')) of
       true ->
	   {bif, element(2, '$1'), element(3, '$1'), '$3'};
       false ->
	   {call, element(2, '$1'), [], element(3, '$1'), '$3'}
   end.
function_call -> atom ':' atom '(' parameter_list ')' :
   {call, element(2, '$1'), element(3, '$1'), element(3, '$3'), '$5'}.

parameter_list -> exprs : '$1'.
parameter_list -> '$empty' : [].


case_expr -> 'case' expr 'of' cr_clauses 'end' :
   {'case', element(2, '$1'), '$2', '$4'}.

cr_clause -> pattern clause_guard clause_body :
   {clause, element(2, '$1'), ['$1'], '$2', '$3'}.

cr_clauses -> cr_clause : ['$1'].
cr_clauses -> cr_clause ';' cr_clauses : ['$1' | '$3'].

if_expr -> 'if' if_clauses 'end' : {'if', element(2, '$1'), '$2'}.

if_clause -> guard clause_body : {clause, element(2, hd('$2')), '$1', '$2'}.

if_clauses -> if_clause : ['$1'].
if_clauses -> if_clause ';' if_clauses : ['$1' | '$3'].

receive_expr -> 'receive' 'after' expr clause_body 'end' :
   {'receive', element(2, '$1'), [], '$3', '$4'}.
receive_expr -> 'receive' cr_clauses 'end' :
   {'receive', element(2, '$1'), '$2'}.
receive_expr -> 'receive' cr_clauses 'after' expr clause_body 'end' :
   {'receive', element(2, '$1'), '$2', '$4', '$5'}.


match_expr -> expr '=' expr :
   case erl_parse:is_term('$1') of
       true ->
	   {match, element(2, '$1'), '$1', '$3'};
       false ->
	   throw({error, {element(2, '$1'), yecc, "illegal lhs in match **"}})
   end.

send_expr -> expr '!' expr :
   Pos = element(2, '$1'),
   {send, Pos, '$1', '$3'}.


exprs -> expr : ['$1'].
exprs -> expr ',' exprs : ['$1' | '$3'].


guard_expr -> basic_type : '$1'.
guard_expr -> guard_expr_list : '$1'.
guard_expr -> guard_expr_tuple : '$1'.
guard_expr -> guard_call : '$1'.
guard_expr -> '(' guard_expr ')' : '$2'.
guard_expr -> guard_expr add_op guard_expr :
   {Op, Pos} = '$2',
   {arith, Pos, Op, '$1', '$3'}.
guard_expr -> guard_expr mult_op guard_expr :
   {Op, Pos} = '$2',
   {arith, Pos, Op, '$1', '$3'}.
guard_expr -> prefix_op guard_expr:
   case '$2' of
       {float, Pos, N} ->
	   case '$1' of
	       {'-', _} ->
		   {float, Pos, -N};
	       {'+', _} ->
		   {float, Pos, N};
	       {Op, Pos1} ->
		   {arith, Pos1, Op, {float, Pos, N}}
	   end;
       {integer, Pos, N} ->
	   case '$1' of
	       {'-', _} ->
		   {integer, Pos, -N};
	       {'+', _} ->
		   {integer, Pos, N};
	       {Op, Pos1} ->
		   {arith, Pos1, Op, {integer, Pos, N}}
	   end;
       _ ->
	   {Op, Pos} = '$1',
	   {arith, Pos, Op, '$2'}
   end.

guard_expr_list -> '[' ']' : {nil, element(2, '$1')}.
guard_expr_list -> '[' guard_expr guard_expr_tail ']' :
   {cons, element(2, '$1'), '$2', '$3'}.

guard_expr_tail -> '|' guard_expr : '$2'.
guard_expr_tail -> ',' guard_expr guard_expr_tail :
 {cons, element(2, '$2'), '$2', '$3'}.
guard_expr_tail -> '$empty' : {nil, 0}.

guard_expr_tuple -> '{' '}' : {tuple, element(2, '$1'), []}.
guard_expr_tuple -> '{' guard_exprs '}' : {tuple, element(2, '$1'), '$2'}.

guard_exprs -> guard_expr : ['$1'].
guard_exprs -> guard_expr ',' guard_exprs : ['$1' | '$3'].


guard_call -> atom '(' guard_parameter_list ')' :
   case erl_parse:erlang_guard_bif(element(3, '$1'), length('$3')) of
       true ->
	   {bif, element(2, '$1'), element(3, '$1'), '$3'};
       false ->
	   throw({error, {element(2, '$1'), yecc, "illegal test in guard **"}})
   end.

guard_parameter_list -> guard_exprs : '$1'.
guard_parameter_list -> '$empty' : [].


bif_test -> atom '(' guard_parameter_list ')' :
   case erl_parse:erlang_guard_test(element(3, '$1'), length('$3')) of
       true ->
	   {test, element(2, '$1'), element(3, '$1'), '$3'};
       false ->
	   throw({error, {element(2, '$1'), yecc, "illegal test in guard **"}})
   end.


guard_test -> bif_test : '$1'.
guard_test -> guard_expr comp_op guard_expr :
   {Op, Pos} = '$2',
   {comp, Pos, Op, '$1', '$3'}.

guard_tests -> guard_test : ['$1'].
guard_tests -> guard_test ',' guard_tests : ['$1' | '$3'].

% guard -> 'true' : [].
guard -> atom :
   case '$1' of
       {atom, _, true} ->
           [];
       _ ->
	   throw({error, {element(2, '$1'), yecc, "illegal test in guard **"}})
   end.
guard -> guard_tests : '$1'.


function_clause -> clause_head clause_guard clause_body :
   {Name, Line, Arity, Parameters} = '$1',
   {function, Line, Name, Arity,
    [{clause, element(2, hd('$3')), Parameters, '$2', '$3'}]}.

clause_head -> atom '(' formal_parameter_list ')' :
   {element(3, '$1'), element(2, '$1'), length('$3'), '$3'}.

formal_parameter_list -> patterns : '$1'.
formal_parameter_list -> '$empty' : [].

clause_guard -> 'when' guard : '$2'.
clause_guard -> '$empty' : [].

clause_body -> '->' exprs: '$2'.


function -> function_clause : '$1'.
function -> function_clause ';' function :
   case '$1' of
       {function, Pos1, Name1, Arity1, [Clause]} ->
	   case '$3' of
	       {function, _, Name1, Arity2, Clauses} ->
		   if
		       Arity1 /= Arity2 ->
			   throw({error, {Pos1, yecc,
				  io_lib:format('arity conflict in definition of ~w',
						[Name1])}});
		       true ->
			   {function, Pos1, Name1, Arity1, [Clause | Clauses]}
		   end;
	       _ ->
		   throw({error, {Pos1, yecc,
			  io_lib:format('missing final dot in def of ~w/~w',
					[Name1, Arity1])}})
	   end
   end.


attribute -> atom : element(3, '$1').
attribute -> '[' farity_list ']' : '$2'.

farity_list -> farity : ['$1'].
farity_list -> farity ',' farity_list : ['$1' | '$3'].

farity -> atom '/' integer : {element(3, '$1'), element(3, '$3')}.


form -> '-' atom '(' attribute ')' :
   {attribute, element(2, '$2'), element(3, '$2'), '$4'}.
form -> function : '$1'.