Why does my "equation" grammar break the parser?

Question

Currently, my parser file looks like this:

%{

#include <stdio.h>
#include <math.h>

int yylex();
void yyerror (const char *s);

%}

%union {
    long num;
    char* str;
}

%start line

%token print
%token exit_cmd

%token <str> identifier
%token <str> string
%token <num> number

%%

line: assignment            {;}
    | exit_stmt             {;}
    | print_stmt            {;}
    | line assignment       {;}
    | line exit_stmt        {;}
    | line print_stmt       {;}
    ;

assignment: identifier '=' number       {printf("Assigning var %s to value %d\n", $1, $3);}
          | identifier '=' string       {printf("Assigning var %s to value %s\n", $1, $3);}
          ;

exit_stmt: exit_cmd         {exit(0);}
         ;

print_stmt: print print_expr      {;}
          ;

print_expr: string          {printf("%s\n", $1);}
          | number          {printf("%d\n", $1);}
          ;

%%

int main(void)
{
    return yyparse();

}

void yyerror (const char *s) {fprintf(stderr, "%s\n", s);}

Giving the input: myvar = 3 gives the output Assigning var myvar = 3 to value 3, as expected. However, modifying the code to include an equation grammar rule breaks such assignments.

Equation grammar:

equation: number '+' number             {$$ = $1 + $3;}
    | number '-' number             {$$ = $1 - $3;}
    | number '*' number             {$$ = $1 * $3;}
    | number '/' number             {$$ = $1 / $3;}
    | number '^' number             {$$ = pow($1, $3);}
    | equation '+' number           {$$ = $1 + $3;}
    | equation '-' number           {$$ = $1 - $3;}
    | equation '*' number           {$$ = $1 * $3;}
    | equation '/' number           {$$ = $1 / $3;}
    | equation '^' number           {$$ = pow($1, $3);}
    ;

Modifying the assignment grammar accordingly as well:

assignment: identifier '=' number       {printf("Assigning var %s to value %d\n", $1, $3);}
          | identifier '=' equation     {printf("Assigning var %s to value %d\n", $1, $3);}
          | identifier '=' string       {printf("Assigning var %s to value %s\n", $1, $3);}
          ;

And giving the equation rule the type of num in the parser's first section:

%type <num> equation

Giving the same input: var = 3 freezes the program.

I know this is a long question but can anyone please explain what is going on here?

Also, here's the lexer in case you wanna take a look.

Answer 1

It doesn't "freeze the program". The program is just waiting for more input.

In your first grammar, var = 3 is a complete statement which cannot be extended. But in your second grammar, it could be the beginning of var = 3 + 4, for example. So the parser needs to read another token after the 3. If you want input lines to be terminated by a newline, you will need to modify your scanner to send a newline character as a token, and then modify your grammar to expect a newline token at the end of every statement. If you intend to allow statements to be spread out over several lines, you"ll need to be aware of that fact while typing input.

There are several problems with your grammar, and also with your parser. (Flex doesn't implement non-greedy repetition, for example.) Please look at the examples in the bison and flex manuals