YACC Parser getting an error at line 1 even if test program is empty? - parsing

Question

I have been trying do my homework which is language design with Lex and YACC. My assignment is building a simple parser with YACC. But my problem is the test file I send to my parser always returns a syntax error on the first line. As far as I realised the parser does not even reach the first statement of the example. The other problem with my program it returns with an error message even if the test program is empty . Here is my Lex and YACC code and the example program I am using.
My Lex Code:
%{
#include <stdio.h>
#include "y.tab.h"
void yyerror(char *);
%}
lowerLetter [a-z]
letter [a-zA-Z]
digit [0-9]
signs [+-]
integer {signs}?{digit}+
double {signs}?{digit}*(\.)?{digit}+
word {lowerLetter}+({letter}*{digit}*)*
string \"[^\"]*\"
day ("Monday"|"Tuesday"|"Wednesday"|"Thursday"|"Friday"|"Saturday"|"Sunday")
month ("January"|"February"|"March"|"April"|"May"|"June"|"July"|"August"|"September"|"October"|"November"|"December")
time {day}(\,)(\ )[0-3][1-9](\ ){month}(\ ){digit}*(\ )[0-2][0-9](\:)[0-5][0-9](\:)[0-5][0-9]((\ )("GMT")(((\+)|(\-)){integer}(\:){integer})?)?
sensor (\$)("s"){digit}*
switch (\$)("sw"){digit}
url ("http")("s")?("://")("www.")?[a-zA-Z0-9]*(\.)(.)*
type ("integer"|"double"|"string"|"sensor"|"switch"|"url"|"boolean"|"time"|"letter")
boolean ("true")|("false")|([a-zA-Z0-9]+((\ )*)?(((\=|\<|\>|\!)(\=))|(\>|\<))+((\ )*)?[a-zA-Z0-9]+)
identifier ({letter}*|{digit}*|(\_)*)*
%%
while return WHILE;
for return FOR;
return return RETURN;
sysin return SYSIN;
sysout return SYSOUT;
if return IF;
main return MAIN;
end return END;
else return ELSE;
fun return FUNCTION_IDENTIFIER;
cons return CONS;
isURL return IS_URL;
connect return CONNECT;
send return SEND;
receive return RECEIVE;
\\\n return NL;
\. return DOT;
\, return COMMA;
\: return COLON;
\; return SEMICOLON;
\+ return PLUS_OP;
\- return MINUS_OP;
\* return MULTIPLY_OP;
\/ return DIVIDE_OP;
\% return MOD_OP;
\# return HASHTAG;
\$ return SENSOR_IDENTIFIER;
\^ return POWER_OP;
\_ return UNDER_SCORE;
\? return QUESTION;
\! return NOT;
\( return LP;
\) return RP;
\{ return LCB;
\} return RCB;
\[ return LSB;
\] return RSB;
\= return ASSN_OP;
\> return GT;
\< return LT;
\=\= return EQ;
\>\= return GEQ;
\<\= return LEQ;
\!\= return NE;
\&\& return AND;
\|\| return OR;
\/\/ return DS;
{day} return DAY;
{month} return MONTH;
{time} return TIME;
{type} return TYPE;
{lowerLetter} return LOWER_LETTER;
{letter} return LETTER;
{integer} return INTEGER;
{string} return STRING;
{sensor} return SENSOR;
{switch} return SWITCH;
{double} return DOUBLE;
{boolean} return BOOLEAN;
{url} return URL;
{word} return WORD;
{identifier} return IDENTIFIER;
[ \t] ;
%%
int yywrap(void)
{
return 1;
}
My YACC code:
%{
#include "stdio.h"
#include <stdlib.h>
void yyerror(char *);
extern int yylineno;
#include "y.tab.h"
int yylex(void);
%}
%token MAIN
%token DOT COMMA COLON SEMICOLON UNDER_SCORE QUESTION LP RP LCB RCB LSB RSB DS NL
%token WHILE FOR RETURN SYSIN SYSOUT IF END ELSE FUNCTION_IDENTIFIER NOT CONS PLUS_OP MINUS_OP MULTIPLY_OP DIVIDE_OP MOD_OP HASHTAG SENSOR_IDENTIFIER POWER_OP
%token ASSN_OP GT LT EQ GEQ LEQ NE AND OR DAY MONTH TIME TYPE IS_URL CONNECT SEND RECEIVE
%token LOWER_LETTER LETTER WORD STRING INTEGER DOUBLE BOOLEAN SENSOR SWITCH URL IDENTIFIER
%nonassoc ELSE
%left PLUS_OP MINUS_OP
%left MULTIPLY_OP DIVIDE_OP
%left POWER_OP MOD_OP
%start program
%%
program:
stmts {printf("\rProgram is valid.\n");};
stmts: stmt
| stmts stmt;
stmt: if_stmt
| non_if_stmt ;
if_stmt: IF LP logical_expr RP LCB stmts RCB
| IF LP logical_expr RP LCB stmts RCB ELSE LCB stmts RCB;
non_if_stmt: loops
| aritmetic_op
| func_call
| func_dec
| initialize
| decl
| decl_ini
| input_stmt
| output_stmt
//| comment
| url_checker
| send
| receive
| connect;
loops: while_loop
| for_loop;
while_loop: WHILE LP logical_expr RP LCB stmts RCB;
for_loop: FOR LP decl_ini SEMICOLON logical_expr SEMICOLON aritmetic_op RP LCB stmts RCB;
initialize: IDENTIFIER ASSN_OP value SEMICOLON;
logical_expr: logical_term logical_op logical_term
| logical_expr logical_connector logical_term
| boolean_stmt;
boolean_stmt: BOOLEAN
| NOT boolean_stmt;
logical_term: term;
//| logical_term AND term;
logical_connector: AND
| OR;
term: IDENTIFIER
| constant;
constant: CONS IDENTIFIER;
logical_op: EQ
| NE
| LT
| GT
| LEQ
| GEQ;
decl: TYPE term SEMICOLON;
decl_ini: TYPE term ASSN_OP value SEMICOLON;
value: number
| STRING
| SENSOR
| SWITCH
| URL
| BOOLEAN
| LETTER
| TIME;
number: DOUBLE
| INTEGER;
/*
value_list: value
| value_list COMMA value;
array_decl: TYPE term LSB RSB SEMICOLON;
array_ini: TYPE term LSB RSB ASSN_OP LSB value_list RSB SEMICOLON
| term ASSN_OP LSB value_list RSB SEMICOLON;
get_array_val: term LSB INTEGER RSB;
*/
func_dec: FUNCTION_IDENTIFIER TYPE IDENTIFIER LP arguments RP LCB function_block RCB;
func_call: IDENTIFIER LP arguments RP SEMICOLON;
function_block: stmts
| stmts RETURN value
| stmts RETURN term;
arguments: TYPE term
| arguments COMMA TYPE term;
aritmetic_op: addition
| subtraction
| multiplication
| division
| modulo
| power;
addition: aritmetic_op PLUS_OP term
| term PLUS_OP term
| term PLUS_OP aritmetic_op;
subtraction: aritmetic_op MINUS_OP term
| term MINUS_OP term
| term MINUS_OP aritmetic_op;
multiplication: aritmetic_op MULTIPLY_OP term
| term MULTIPLY_OP term
| term MULTIPLY_OP aritmetic_op;
division: aritmetic_op DIVIDE_OP term
| term DIVIDE_OP term
| term DIVIDE_OP aritmetic_op;
modulo: aritmetic_op MOD_OP term
| term MOD_OP term
| term MOD_OP aritmetic_op;
power: aritmetic_op POWER_OP term
| term POWER_OP term
| term POWER_OP aritmetic_op;
/*
comment:
| DS sentence NL;
sentence:
| IDENTIFIER
| DOT | COMMA | COLON | SEMICOLON | PLUS_OP | MINUS_OP | MULTIPLY_OP | DIVIDE_OP
| MOD_OP | HASHTAG | SENSOR_IDENTIFIER | POWER_OP | UNDER_SCORE | QUESTION | NOT
| LP | RP | LCB | RCB | ASSN_OP | GT | LT
| sentence sentence;
*/
input_stmt: TYPE term ASSN_OP SYSIN LP RP SEMICOLON
| SYSIN LP RP SEMICOLON;
output_stmt: SYSOUT LP output RP SEMICOLON;
output: term
| value
| aritmetic_op
| output COMMA term;
url_checker: IS_URL LP STRING RP
| IS_URL LP term RP;
connect: CONNECT LP URL RP;
send: SEND LP number COMMA URL RP;
receive: RECEIVE LP URL RP;
%%
void yyerror(char *s)
{
fprintf(stderr, "syntax error at line: %d %s\n", yylineno, s);
}
int main(void){
yyparse();
if(yynerrs < 1) printf("there are no syntax errors!!\n");
}
My Simple Test Program:
integer a = 5;
double e = 5.5;
double f = 3.0;
sadasd
My Extended Test Program
sensor a = $s1;
switch b = $sw1;
integer c = -5;
integer d = 75;
double e = 5.5;
double f = 3.0;
c = c + d;
f = f + e;
sysout (e + f);
integer g = sysin();
url k = https://www.cs.bilkent.edu.tr/~guvenir/courses/CS315/Pr1.htm;
url l = https://docs.oracle.com/cd/E19504-01/802-5880/lex-6/index.html;
if(isURL(k)){connect(k);} //Connecting to URL k after checking if its a URL
send(g, k); //Sending the integer g to the URL k
integer h = receive(l); //Receiving the integer h from URL l
sysout (h); //Printing the integer h which we took from the URL l
if (e > f) {
e = f + e;
}else{
e = f - e;
}
time t = Friday, 14 October 2022 18:05:52
time t = Monday, 17 October 2022 12:05:52 GMT
time t = Saturday, 22 October 2022 20:05:52 GMT+03:00 //Defining time in different ways
while (e > f) {
e = e - f;
}
for (integer i = 0, e <= f, i = i + 1) {
e = e + i;
}
fun boolean isGreater(integer x, integer y){
boolean z = (x > y);
return z;
}
boolean g = isGreater(e, f);
sysout (k);
sysout (l);
And My Make file:
LEX = lex
YACC = yacc -d
CC = gcc
all: parser clean
parser: y.tab.o lex.yy.o
$(CC) -o parser y.tab.o lex.yy.o
./parser < test.txt
lex.yy.o: lex.yy.c y.tab.h
lex.yy.o y.tab.o: y.tab.c
y.tab.c y.tab.h: y.y
$(YACC) -v y.y
lex.yy.c: lex.l
$(LEX) lex.l
clean:
-rm -f *.o lex.yy.c *.tab.* parser *.output