Adding abs(x) and sqrt(x) functions to flex/bison calculator - calculator

Question

I have to make a calculator in flex/bison for a lab in class and I have to add functionality to compute square roots or absolute values in they put in sqrt(x) or abs(x). I imported the math library and I got the caculator to work if the COMMAND FOR IT CONSIST OF ONE CHARACTER. Here's what I mean:
expr:
......
| '(' expr ')' { $$ = fabs($2); } //for abs
| '[' expr ']' {$$ = sqrt($2); } //for sqrt
.......
now, this works fine and if i put in (-2) i get 2, or [4] = 2. The problem is clearly, i need to make it so the command is abs(x) and sqrt(x). If I switch the code to say
| "abs(" expr ')' { $$ = fabs($2); } //for abs
| "sqrt" expr ']' {$$ = sqrt($2); } //for sqrt
this doesn't work because it sees the a then b, and tries to do something with that. This is likely because my calculator also supports assigning variable values (like x=2), so it thinks there should be an operator between a and b. I unfortunately have no idea how to fix this. I would appreciate any help.
Here's my code if that helps:
hexcalc.y
%{
#include <stdio.h>
#include <math.h>
#include <stdlib.h> // often required
// A simple error message to move things along
void yyerror(const char *msg)
{
printf("ERROR(PARSER): %s\n", msg);
}
// Storage for variables: yes Virginia, only 26 variables possible in this langu$
long variables[26];
%}
%union {
float nvalue;
int ivalue;
int varindex;
}
%token <nvalue> NUMBER
%token <ivalue> INT
%token <varindex> NAME
%type <nvalue> expr
%type <nvalue> term
%type <nvalue> varOrNum
%%
statementList : statement '\n'
| statement '\n' statementList
;
statement : NAME '=' expr { variables[$1] = $3; }
| expr { printf("RESULT: %f\n", $1); }
;
expr: expr '+' term { $$ = $1 + $3; }
| expr '-' term { $$ = $1 - $3; }
| '-' term { $$ = 0 - $2; }
| "abs(" expr ')' { $$ = $2; }
| "sqrt(" expr ')' { $$ = sqrt($2); }
| expr '/' term { $$ = $1 / $3; }
| term { $$ = $1; }
;
term : term '*' varOrNum { $$ = $1 * $3; }
| varOrNum { $$ = $1; }
;
varOrNum : NUMBER { $$ = $1; }
| NAME { $$ = variables[$1]; }
;
%%
main() {
int i;
for (i=0; i<26; i++) variables[i] = 0;
yyparse();
}
hexcalc.l
%{
#include <stdlib.h>
#include <math.h>
#include "hexcalc.h"
#define BASE 10
char* endptr;
%}
%%
[a-z] { yylval.varindex = yytext[0] - 'a'; $
}
[0-9]+ { yylval.nvalue = atof(yytext);
return NUMBER;
}
[0-9]+"."[0-9]+?|"."[0-9]+? {yylval.nvalue = atof(yytext);
return NUMBER;
}
[ \t] ;
\n|. { return yytext[0];
}
%%
int yywrap() {
return 1;
}

Answer 1

You need to recognize multicharacter names in the lexer as single tokens and then use them in your grammar. The easy way is to just add them to your lexer:
abs { return ABS; }
sqrt { return SQRT; }
Then you can add to your parser:
%token ABS SQRT
%%
expr: ABS '(' expr ')' { $$ = fabs($3); }
| SQRT '(' expr ')' { $$ = sqrt($3); }

Answer 2

You need to create rules in your .l file for "abs" and "sqrt"; declare the tokens they will each return via %token; and use those token names in the grammar rules: ABS "(" expr ")" : ...

Answer 3

You should have a look at Bison's documentation where a more scalable solution for predefined functions is given (using a symbol table).
http://www.gnu.org/software/bison/manual/html_node/Multi_002dfunction-Calc.html