Bison shift/reduce conflict, cannot remove ambiguity from parser - c++

Question

When I run my bison code in Linux Mint I get these warnings:
warning: 64 shift/reduce conflicts [-Wconflicts-sr]
I cannot find the ambiguity. I've tried to make my implementation hanlde both INT and FLOAT datatypes, but I believe that is the source of the warnings.
My Bison code is below:
%{
/**
* Definition section
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <cstdio>
#include <iostream>
using namespace std;
/**
* Declare stuff from Flex that Bison needs to know about:
*/
extern int yylex();
extern int yyparse();
extern FILE* yyin;
extern int line_num;
void yyerror(const char* s);
%}
/** Bison fundamentally works by asking flex to get the next token,
* which it returns as an object of type "yystype". Initially (by default),
* yystype is merely a typedef of "int", but for non-trivial projects, tokens
* could be of any arbitrary data type. So, to deal with that, the idea is to
* override yystype's default typedef to a C union instead. Unions can hold all
* of the types of tokens that Flex could return, and this means we can return
* ints or floats or string cleanly. Bison implements this mechanism with the
* %union directive:
*/
%union {
int ival;
float fval;
}
/**
* Define the "Terminal Symbol" toke types. We use (in CAPS by convention),
* and associate each with a field of the %union:
*/
%token<ival> INT
%token<fval> FLOAT
%token PLUS MINUS MULTIPLY DIVIDE
%token NEWLINE QUIT
%type<ival> expression
%type<fval> mixed_expression
%start calculation
%%
calculation:
| calculation line
;
line: NEWLINE
| mixed_expression NEWLINE {printf("\tResult: %f\n", $1);}
| expression NEWLINE {printf("\tResult: %i\n", $1);}
| QUIT NEWLINE {printf("bye!\n"); exit(0);}
;
mixed_expression: FLOAT {$$ = $1;}
| mixed_expression PLUS mixed_expression {$$ = $1 + $3;}
| mixed_expression MINUS mixed_expression {$$ = $1 - $3;}
| mixed_expression MULTIPLY mixed_expression {$$ = $1 * $3;}
| mixed_expression DIVIDE mixed_expression {$$ = $1 / $3;}
| expression PLUS mixed_expression {$$ = $1 + $3;}
| expression MINUS mixed_expression {$$ = $1 - $3;}
| expression MULTIPLY mixed_expression {$$ = $1 * $3;}
| expression DIVIDE mixed_expression {$$ = $1 / $3;}
| mixed_expression PLUS expression {$$ = $1 + $3;}
| mixed_expression MINUS expression {$$ = $1 - $3;}
| mixed_expression MULTIPLY expression {$$ = $1 * $3;}
| mixed_expression DIVIDE expression {$$ = $1 / $3;}
| expression DIVIDE expression {$$ = $1 / (float)$3;}
;
expression: INT {$$ = $1;}
| expression PLUS expression {$$ = $1 + $3;}
| expression MINUS expression {$$ = $1 - $3;}
| expression MULTIPLY expression {$$ = $1 * $3;}
;
%%
int main(int, char**) {
// Open a file handle to a particular file:
FILE *myfile = fopen("numbers.txt", "r");
// Make sure it is valid:
if(!myfile) {
cout << "I can't open numbers.txt!" << endl;
return -1;
}
// Set Flex to read from it instead of defaulting to STDIN:
yyin = myfile;
// Parse through the input:
yyparse();
}
void yyerror(const char *s) {
cout << "AAAHHHH, parse error on line " << line_num << "! Message: " << s << endl;
// might as well halt now:
exit(-1);
}
I believe that the issue may be with my implementation of expression and mixed_expression.

Answer 1

The datatype of a computation is semantic, not syntactic; intuitively, one wouldn't expect a grammar to deal with it. Under some very limited circumstances it's possible — your attempt is workable, at least until you decide to implement variables — but it's almost never a good idea.
But that's not what's producing the shift-reduce conflicts. The problem is that your grammar is ambiguous and you have not told Bison how to resolve the ambiguities. The grammar is ambiguous because 4-2*3 could be parsed either as expression(4-2) TIMES expression(3) or as expression(4) MINUS expression(2*3), which obviously have different values. The usual way to resolve this particular ambiguity is through precedence declarations, which you will find deployed in pretty well all of the useful example parsers.