%{
/************************
 $Id: simple.lr,v 1.4 1993/09/20 00:07:35 Exp $
 ************************/

 /* Simple in C....  LR grammar.  */
#include "semform.h"
extern char yytext[];
%}
%token Iconst Id 
%token Rparen Lparen Plussym Minussym Mpysym Divsym Assignop Readln
%token Write Writeln Commasym Termsym Strconst
%token If Then End Eqop
%%
pgm 		: 	stmtlist 
			{lr_debug ("program  -> stmtlist");
			Done(); }

expr		:	expr addop term
			{lr_debug ("expr     -> expr addop term");
			DoArithOp();}
			|
			term
			{lr_debug ("expr     -> term");}

term		:	term multop fact 
                        {lr_debug ("term     -> term multop fact"); 
                        DoArithOp(); }
			|
			fact 
			{lr_debug ("term     -> fact");}

fact		:	unaryop primary
			{lr_debug ("fact     -> unaryop primary");
			PerformUnary();}
			|
			primary
			{lr_debug ("fact     -> primary");}

unaryop		:	addop
			{lr_debug (" unaryop -> addop");}
			
primary		:	Lparen expr Rparen
                        {lr_debug ("primary  -> Lparen expr Rparen");}
			|
			integer_const  
                        {lr_debug ("primary  -> integer_const"); 
                        IconstReduce(); }
			|
			memref  
                        {lr_debug ("primary  -> memref"); 
                        AddrToPrimary(); }

memref		:	identifier  
                        {lr_debug ("memref   -> identifier"); 
                        IdToAddr(); }

addop		:	Plussym  
                        {lr_debug ("addop    -> Plussym"); 
                        Operator(AddOp); }
			|
			Minussym 
                        {lr_debug ("addop    -> Minussym"); 
                        Operator(SubOp); }

multop		:	Mpysym 
                        {lr_debug ("multop   -> Mpysym"); 
                        Operator(MpyOp); }
			|
			Divsym 
                        {lr_debug ("multop   -> Divsym"); 
			Operator(DivOp); }

stmtlist	:	stmtlist stmt 
                        {lr_debug ("stmtlist -> stmtlist stmt"); 
                        MergeStmts(); }
			|
			lambda 
                        {lr_debug ("stmtlist -> lambda"); 
                        NullList(); }

stmt		:	assignstmt Termsym
                        {lr_debug ("stmt     -> assignstmt Termsym");}
			|
			readstmt   Termsym
                        {lr_debug ("stmt     -> readstmt Termsym");}
			|
			writestmt  Termsym
                        {lr_debug ("stmt     -> writestmt Termsym");}
			|
			ifstmt	Termsym
                        {lr_debug ("stmt     -> ifstmt Termsym");}

ifstmt		:	If boolexpr Then stmtlist End If 
                        {lr_debug ("ifstmt   -> If boolexpr Then stmtlist End If"); 
                        MakeIf(); }

boolexpr	:	expr Eqop expr 
                        {lr_debug ("boolexpr -> expr Eqop expr");
                        IfTest(); }

assignstmt	:	memref Assignop expr 
                        {lr_debug ("assignstmt->memeref Assignop expr");
                        Assign(); }

readstmt	:	Readln Lparen memreflist Rparen 
			{lr_debug("readstmt -> Readln Lparen memreflist Rparen");
			Call(ReadlnProc); }
			|
			Readln 
                        {lr_debug ("readstmt -> Readln"); 
                        Call2(ReadlnProc); }

writestmt	:	Write Lparen actparamlist Rparen 
                        {lr_debug 
			("writestmt-> Write Lparen actparamlist Rparen)");
                        Call(WriteProc); }
			|
			Writeln Lparen actparamlist Rparen 
			{lr_debug 
			("writestmt-> Writeln Lparen actparamlist Rparen"); 
                        Call(WritelnProc); }
			|
			Writeln 
                        {lr_debug ("writestmt : Writeln");
                        Call2(WritelnProc); }

memreflist	:	memreflist Commasym memref 
                        {lr_debug ("memreflist->memreflist Commasym memref"); 
                        MergeMemParam(); }
			|
			memref 
                        {lr_debug ("memreflist->memref"); 
                        CreateMemParam(); }

actparamlist	:	actparamlist Commasym actparam 
                        {lr_debug 
			("actparamlist->actparamlist Commasym actparam"); 
                        MergeActParam(); }
			|
			actparam
                        {lr_debug ("actparamlist->actparam");}

actparam	:	expr 
                        {lr_debug ("actparam  -> expr");
                        CreateActParam(); }
			|
			Strconst {
		lr_debug ("actparam -> Strconst");
			pushstring(yytext);
				  CreateActParam(); }

integer_const	:	Iconst  
                        {lr_debug ("integer_const-> Iconst");
                        PushInt( atoi(yytext) ); }

identifier	:	Id  
                        {lr_debug ("identifier->Id "); 
                        PushId( yytext ); }

lambda		:	;
%%

int lr_debug(s)
char s[];
{
	char sst[81];
	if (SL_dump)
	{ printf ("grammar: %s\n",s); }
	return 1;
}