Create a new folder called Evaluator in your Home folder.

Using an editor (TextEdit, GNU Emacs, or vi), create a file called Makefile in your Evaluator directory containing the following:

CFLAGS = -O
SRCS = y.tab.c lex.yy.c
LFLAGS =  -ly -ll -lm
Evaluator: $(SRCS)
        cc $(CFLAGS) -o Evaluator $(SRCS) $(LFLAGS)

clean:
        /bin/rm -f Evaluator $(SRCS) *.h

lex.yy.c: rules.l y.tab.h 
        lex rules.l

y.tab.h: grammar.y
        yacc -d grammar.y

y.tab.c: grammar.y
        yacc grammar.y

Using an editor, create a file called grammar.y in your Evaluator directory containing the following:

%{
#include <libc.h>
#include <math.h>

int printingError = 0;
%}

%start list

%union
{
   int    ival;
   double dval;
}

%token <dval> NUMBER
%token <dval> SIN COS TAN ASIN ACOS ATAN
%token <dval> SINH COSH TANH ASINH ACOSH ATANH
%token <dval> SQRT MOD LN LOG PI
%type  <dval> expr number 

%left '+' '-'
%left '*' '/' 
%left SIN COS TAN ASIN ACOS ATAN SINH COSH TANH ASINH
%left ACOSH ATANH
%left '^' SQRT MOD LN LOG
%left UMINUS   /* supplies precedence for unary minus */

%%             /* beginning of rules section */

list : stat
     | list stat
     ;

stat : expr '
'
{
  printf("%10g
",$1);
  printingError = 0;
  fflush(stdout);
}
;

expr   : '(' expr ')'
{
  $$ = $2;
}
  | expr '+' expr   { $$ = $1 + $3;}
  | expr '-' expr   { $$ = $1 - $3;}
  | expr '*' expr   { $$ = $1 * $3;}
  | expr '/' expr   { $$ = $1 / $3;}
  | SIN expr                               { $$ = sin($2);}
  | COS expr                               { $$ = cos($2);}
  | TAN expr                               { $$ = tan($2);}
  | ASIN expr                              { $$ = asin($2);}
  | ACOS expr                              { $$ = acos($2);}
  | ATAN expr                              { $$ = atan($2);}
  | SINH expr                              { $$ = sinh($2);}
  | COSH expr                              { $$ = cosh($2);}
  | TANH expr                              { $$ = tanh($2);}
  | ASINH expr                             { $$ = asinh($2);}
  | ACOSH expr                             { $$ = acosh($2);}
  | ATANH expr                             { $$ = atanh($2);}
  | expr '^' expr                          { $$ = pow($1,$3);}
  | expr MOD expr                          { $$ = fmod($1,$3);}
  | LN expr                                { $$ = log($2);}
  | LOG expr                               { $$ = log10($2);}
  | SQRT expr                              { $$ = sqrt($2);}
  | '-' expr %prec UMINUS
  {
     $$ = -$2;
  }
  | number
    ;

number      : NUMBER   /* lex number */
  | PI      { $$ = M_PI;        }
  ;

%% /* beginning of functions section */
void yyerror(char *s)
{
  if (printingError == 0) {
     printf("Syntax Error
");
     fflush(stdout);
     printingError = 1;
  }
}

int main(int argc,char **argv)
{
  while (!feof(stdin)) {
     yyparse(  );
  }
  exit(0);
}

Using an editor, create a file called rules.l ^[30] in your Evaluator directory containing the following:

%{
#include "y.tab.h"
#include <stdlib.h>

#define YY_INPUT(buf,result,max_size) (buf[0])=getchar(  );result=1;

int yywrap(void);
int yywrap(  ){return 0;}

%}

%%

"
" return('
'),

[0-9]*("."[0-9]*("e"[-+][0-9]+)?)?  {yylval.dval = atof(yytext); 
    return(NUMBER);}

sin        return(SIN);     // NOTE: In this section, be sure to use
cos        return(COS);     // a tab after the 'sin' and each of
tan        return(TAN);     // the other function names. If you use
asin       return(ASIN);    // spaces, this code will not compile
acos       return(ACOS);    // properly.
atan       return(ATAN);
sinh       return(SINH);
cosh       return(COSH);
tanh       return(TANH);
asinh      return(ASINH);
acosh      return(ACOSH);
atanh      return(ATANH);
mod        return(MOD);
ln         return(LN);
log        return(LOG);
sqrt       return(SQRT);
pi         return(PI);

[ 	]     ;

.         {return(yytext[0]);}

%%

Open up a Unix shell window in the Terminal application.

Compile the Evaluator program with the make utility by typing make in the Terminal window. What you should type is shown here in bold:

% cd ~/Evaluator
% make
yacc grammar.y
yacc -d grammar.y
lex rules.l
cc -O -o Evaluator y.tab.c lex.yy.c -ly -ll -lm
%

After compiling the program, test it with a few mathematical expressions, as follows:

% cd ~/Evaluator
% ./Evaluator
                        10+20
        302002/2001
    1.0005sin(2*pi) + cos(4*pi)
         1
^C%>