pl0yacc.ypp

%{
	#include <stdio.h>

	int yylex(void);
	void yyerror(char *);
	/* To construct a structure to help in error reporting. It is
	   automatically managed by bison.
	*/


	typedef struct YYLTYPE
	{
	  int first_line;
	  int first_column;
	  int last_line;
	  int last_column;
	} YYLTYPE;

	# define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition*/
%}

%union {
	char* str;
	int num;
}

%locations
%token 	ASSIGNMENT DIVIDE MULTIPLY ADD SUB
%token	RB LB GE LE NE EQ GT LT COMMA
%token	DOT SEMICOLON BEGN CALL CONST DO
%token	END IF ODD PROCEDURE THEN VAR WHILE

%token <num> NUMBER
%token <str> ID

%%

program			:		block DOT											{printf("program rule\n");}
						;

block			:		const_decl var_decl proc_decl statement				{printf("block rule\n");}
						;

const_decl		:		CONST seq_assign SEMICOLON 							{printf("const_decl rule\n");}
						|													{printf("const-decl rule empty\n");}
						;

seq_assign		:		seq_assign COMMA ID EQ NUMBER 						{printf("seq_assign rule recursive\n");}
						| ID EQ NUMBER 										{printf("seq_assign rule non-recursive\n");}
						;

var_decl		:		VAR seq_decl SEMICOLON 								{printf("var_decl rule\n");}
						| 													{printf("var_decl rule empty\n");}
						;

seq_decl		:		seq_decl COMMA ID 									{printf("seq_decl rule recursive\n");}
						|ID 												{printf("seq_decl rule non-recursive\n");}
						;

proc_decl		:		proc_decl PROCEDURE ID SEMICOLON block SEMICOLON 	{printf("proc_decl rule recursive\n");}
						| 													{printf("proc_decl rule empty\n");}
						;

statement		:		ID ASSIGNMENT expression 							{printf("statement assignment rule\n");}
						| CALL ID											{printf("statement call rule\n");}
						| BEGN seq_stmt END 								{printf("statement begin end rule\n");}
						| WHILE condition DO statement 						{printf("statement while rule\n");}
						| IF condition THEN statement 						{printf("statement if rule\n");}
						| 													{printf("statement empty rule\n");}
						;
seq_stmt		:		seq_stmt SEMICOLON statement 						{printf("seq_stmt rule recursive\n");}
						| statement											{printf("seq_stmt rule non-recursive\n");}
						;

expression		:		term seq_term 										{printf("expression rule 1\n");}
						| sterm seq_term 									{printf("expression rule 2\n");}
						;

sterm			:		ADD term 											{printf("add term rule\n");}
						| SUB term											{printf("sub term rule\n");}
						;

seq_term		:		seq_term sterm										{printf("seq_term recursive rule\n");}
						| 													{printf("seq_term rule empty\n");}
						;

condition		:		ODD expression 										{printf("condition ODD\n");}
						| expression GE expression	 						{printf("condition GE\n");}
						| expression LE expression	 						{printf("condition LE\n");}
						| expression GT expression 	 						{printf("condition GT\n");}
						| expression LT expression 	 						{printf("condition LT\n");}
						| expression NE expression 	 						{printf("condition NE\n");}
						| expression EQ expression 	 						{printf("condition EQ\n");}
						;

term			:		factor seq_factor 									{printf("term rule\n");}
						;

seq_factor		:		seq_factor MULTIPLY factor 							{printf("seq_factor rule MUL recursive\n");}
						|seq_factor DIVIDE factor 							{printf("seq_factor rule DIV recursive\n");}
						| 													{printf("seq_factor rule empty\n");}
						;

factor			:		ID 													{printf("ID found: %s\n",yylval.str);}
						| NUMBER 											{printf("NUMBER found\n");}
						| LB expression RB									{printf("parenthesized expression found\n");}
						;

%%

void
yyerror(char *s, ...)
{
  va_list ap;
  va_start(ap, s);

  if(yylloc.first_line)
    fprintf(stderr, "%d.%d-%d.%d: error: ", yylloc.first_line, yylloc.first_column,
	    yylloc.last_line, yylloc.last_column);
  vfprintf(stderr, s, ap);
  fprintf(stderr, "\n");

}

void
lyyerror(YYLTYPE t, char *s, ...)
{
  va_list ap;
  va_start(ap, s);

  if(t.first_line)
    fprintf(stderr, "%d.%d-%d.%d: error: ", t.first_line, t.first_column,
	    t.last_line, t.last_column);
  vfprintf(stderr, s, ap);
  fprintf(stderr, "\n");
}

int main() {
	return yyparse();
}