Create a gist now

Instantly share code, notes, and snippets.

@gabocze /calc.c
Last active Jan 9, 2017

What would you like to do?
Exercice 1 from the Bison Manual for the version 3.0.4, Chapter 2, § 6: Add some new functions from math.h to the initialization list. https://www.gnu.org/software/bison/manual/html_node/index.html
#include "calc.h" /* Contains definition of ’symrec’. */
/* The symbol table: a chain of ’struct symrec’. */
symrec *sym_table;
struct init
{
char const *fname;
double (*fnct) (double);
double (*fnct2) (double, double);
};
struct init const arith_fncts[] =
{
{ "atan", atan, 0 },
{ "cos", cos, 0 },
{ "exp", exp, 0 },
{ "ln", log, 0 },
{ "sin", sin, 0 },
{ "sqrt", sqrt, 0 },
{ "pow", 0, pow },
{ 0, 0, 0 },
};
/* Put arithmetic functions in table. */
static
void
init_table (void)
{
int i;
for (i = 0; arith_fncts[i].fname != 0; i++)
{
symrec *ptr = putsym (arith_fncts[i].fname, FNCT);
if(arith_fncts[i].fnct!=0)
ptr->value.fnctptr = arith_fncts[i].fnct;
if(arith_fncts[i].fnct2!=0)
ptr->value.fnctptr2 = arith_fncts[i].fnct2;
}
}
#include <stdlib.h> /* malloc. */
#include <string.h> /* strlen. */
symrec *
putsym (char const *sym_name, int sym_type)
{
symrec *ptr = (symrec *) malloc (sizeof (symrec));
ptr->name = (char *) malloc (strlen (sym_name) + 1);
strcpy (ptr->name,sym_name);
ptr->type = sym_type;
ptr->value.var = 0; /* Set value to 0 even if fctn. */
ptr->next = (struct symrec *)sym_table;
sym_table = ptr;
return ptr;
}
symrec *
getsym (char const *sym_name)
{
symrec *ptr;
for (ptr = sym_table; ptr != (symrec *) 0;
ptr = (symrec *)ptr->next)
if (strcmp (ptr->name, sym_name) == 0)
return ptr;
return 0;
}
#include <ctype.h>
int
yylex (void)
{
int c;
/* Ignore white space, get first nonwhite character. */
while ((c = getchar ()) == ’ ’ || c == ’\t’)
continue;
if (c == EOF)
return 0;
/* Char starts a number => parse the number. */
if (c == ’.’ || isdigit (c))
{
ungetc (c, stdin);
scanf ("%lf", &yylval.NUM);
return NUM;
}
/* Char starts an identifier => read the name. */
if (isalpha (c))
{
/* Initially make the buffer long enough
for a 40-character symbol name. */
static size_t length = 40;
static char *symbuf = 0;
symrec *s;
int i;
if (!symbuf)
symbuf = (char *) malloc (length + 1);
i = 0;
do
{
/* If buffer is full, make it bigger. */
if (i == length)
{
length *= 2;
symbuf = (char *) realloc (symbuf, length + 1);
}
/* Add this character to the buffer. */
symbuf[i++] = c;
/* Get another character. */
c = getchar ();
}
while (isalnum (c));
ungetc (c, stdin);
symbuf[i] = ’\0’;
s = getsym (symbuf);
if (s == 0)
s = putsym (symbuf, VAR);
*((symrec**) &yylval) = s;
return s->type;
}
/* Any other character is a token by itself. */
return c;
}
/* Called by yyparse on error. */
void
yyerror (char const *s)
{
fprintf (stderr, "%s\n", s);
}
int
main (int argc, char const* argv[])
{
int i;
/* Enable parse traces on option -p. */
for (i = 1; i < argc; ++i)
if (!strcmp(argv[i], "-p"))
yydebug = 1;
init_table ();
return yyparse ();
}
/* Function type. */
typedef double (*func_t) (double);
typedef double (*func2_t) (double, double);
/* Data type for links in the chain of symbols. */
struct symrec
{
char *name; /* name of symbol */
int type; /* type of symbol: either VAR or FNCT */
union
{
double var; /* value of a VAR */
func_t fnctptr; /* value of a FNCT with 1 parameter */
func2_t fnctptr2; /* value of a FNCT with 2 parameters */
} value;
struct symrec *next; /* link field */
};
typedef struct symrec symrec;
/* The symbol table: a chain of ’struct symrec’. */
extern symrec *sym_table;
symrec *putsym (char const *, int);
symrec *getsym (char const *);
%{
#include <stdio.h> /* For printf, etc. */
#include <math.h> /* For pow, used in the grammar. */
#include "calc.h" /* Contains definition of ’symrec’. */
int yylex (void);
void yyerror (char const *);
%}
%define api.value.type union /* Generate YYSTYPE from these types: */
%token <double> NUM /* Simple double precision number. */
%token <symrec*> VAR FNCT /* Symbol table pointer: variable and function.*/
%type <double> exp
%precedence ’=’
%left ’-’ ’+’
%left ’*’ ’/’
%precedence NEG /* negation--unary minus */
%right ’^’ /* exponentiation */
%% /* The grammar follows. */
input:
%empty
| input line
;
line:
’\n’
| exp ’\n’ { printf ("%.10g\n", $1); }
| error ’\n’ { yyerrok; }
;
exp:
NUM { $$ = $1; }
| VAR { $$ = $1->value.var; }
| VAR ’=’ exp { $$ = $3; $1->value.var = $3; }
| FNCT ’(’ exp ’)’ { $$ = (*($1->value.fnctptr))($3); }
| FNCT ’(’ exp ',' exp ’)’ { $$ = (*($1->value.fnctptr2))($3, $4); }
| exp ’+’ exp { $$ = $1 + $3; }
| exp ’-’ exp { $$ = $1 - $3; }
| exp ’*’ exp { $$ = $1 * $3; }
| exp ’/’ exp { $$ = $1 / $3; }
| ’-’ exp %prec NEG { $$ = -$2; }
| exp ’^’ exp { $$ = pow ($1, $3); }
| ’(’ exp ’)’ { $$ = $2; }
;
/* End of grammar. */
%%
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment