/***************************************************************
   *  Parser accepting variables beginning with an upcase letter  *
   *  with possibility to save formulas to an output file.        * 
   *                                                              *
   *                           English version 6.0 - 08/20/2002   *
   *                                       by J-P MOREAU, Paris.  *
   *                                        (www.jpmoreau.fr)     *
   * ------------------------------------------------------------ *
   *            Examples of valid expressions:                    *
   *                  A=10/4                                      *
   *                  B=25.478                                    *
   *                  C=-1                                        *
   *	              X=0.72                                      *
   *	              F=A*X^2+B*X+C                               *
   *                  F                                           *
   *                  25.75*2+1.784                               *
   *                  2*pi*R                                      *
   * ------------------------------------------------------------ *
   *     Example 1:   F=A/B  )                                    *
   *                  A=500  )  in any order                      *
   *                  B=2    )                                    *
   *                  F                                           *
   *                  250.00000000                                *
   * ------------------------------------------------------------ *
   *     Example 2:   S=L*M                                       *
   *                  V=S*H                                       *
   *                  P=D*V                                       *
   *                  L=100                                       *
   *                  M=50                                        *
   *                  H=5                                         *
   *                  D=1.6                                       *
   *                  P                                           *
   *                  40000.00000000                              *
   * ------------------------------------------------------------ *
   *     Example 3: exp(1)                                        *
   *                2.71828183                                    *
   *                sin(2)                                        *
   *     Résultat : 0.90929743                                    *
   *                root(225)                                     *
   *                15.00000000                                   *
   * ------------------------------------------------------------ *
   *     Example 4: Mass = 2500                                   *
   *                Surface=2*pi*Radius                           *
   * ------------------------------------------------------------ *
   * Example 5: F=A*X+B                                           *
   *            F                                                 *
   *           Formula: A*X+B                                     *
   *           No formula or assignation for variable A           *
   *           No formula or assignation for variable X           *
   *           No formula or assignation for variable B           *
   *           0.00000000                                         *
   * ------------------------------------------------------------ *
   * Version 5.0: possibility to read/save a session from/to a    *
   '*             text file and menu to choose an operation.      *
   * ------------------------------------------------------------ *
   * Version 6.0: Function names can have several letters (cos,   *
   *              sin, atan, etc.).                               *
   ***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
#include <malloc.h>

#define DELIMITER 1
#define VARIABLE  2
#define NUMBER    3
#define NB_VAR    40   // Maximum number of variables
#define PI 4*atan(1)

char *prog;            // pointer to expression to evaluate
char bak[100];         // store previous expression
char token[40];        // current element (operator, variable or number
char tok_type;         // type of current element (1, 2 or 3)

// pointer to a formula such as A...=...
char *formule[NB_VAR];
// pointer to a name of variable
char *vrbl[NB_VAR];

int flg[NB_VAR];       // 0=no 1=yes
int indice;            // number of the formula (0 to NB_VAR-1)
int num=0;             // number of next variable (0 to NB_VAR-1)
int ok;                // allows or not to display result
double answer;         // current result
FILE *fp_in, *fp_out;  // pointers to input/output files
char nom_in[40], nom_out[40]; // names of input/output files
char choice[2];         // choose an option in menu

// table of error messages
static char *ERR[]= {
  "Syntax error.",
  "Odd number of parentheses !",
  "No expression entered.",
  "Divide by zero !",
  "Argument of log negative or null !",
  "Argument of ln negative or null !",
  "Argument of root negative !",
  "INFINITY.",
  "Memory allocation error !"
};

// headers offunctions used
void calcule_exp(),level2(double *),level3(double *),level4(double *),level5(double *);
void level6(double *),primitive(double *),get_token(),arith(char,double *,double *);
void unary(char *,double *), serror(int), menu();
double find_var(char *);
int get_formula();
int isdelim(char), is_in(char,char *);


 /************************************************
 * Entry point in expression parser              *
 *   input : expression prog                     *
 *   output: numerical value result              *
 * --------------------------------------------- *
 * NOTA - It is a recursive descent parser.      *
 * Ref.: "Advanced Turbo C by Herbert Schildt,   *
 *        Borland-Osborne/McGraw-Hill 1987".     *
 ************************************************/
  void calcule_exp(double *result) {
    get_token();
    if(!*token) {
      serror(2);
      return;
    }
    level2(result);
  }

// add or substract two terms
  void level2(double *result) {
    register char op;
    double hold;
    level3(result);
    while((op=*token)=='+' || op == '-') {
      get_token();
      level3(&hold);
      arith(op,result,&hold);
    }
  }

// multiply or divide two terms
  void level3(double *result) {
    register char op;
    double hold;
    level4(result);
    while((op=*token)=='*' || op == '/' || op == '%') {
      get_token();
      level4(&hold);
      arith(op,result,&hold);
    }
  }

// integer power or not
  void level4(double *result)  {
    double hold;
    level5(result);
    if(*token=='^') {
      get_token();
      level4(&hold);
      arith('^',result,&hold);
    }
  }

 /*********************************************************
 *         Unary operator: +, - or function               *
 * ------------------------------------------------------ *
 *        Implemented functions are:                      *
 * acos for arc cosinus, asin for arc sinus, atan for     *
 * arc tangent, cos for cosinus, exp for exponential,     *
 * log pour decimal logarithm, ln pour neperian logarithm,*
 * the constant pi, root for square root, sin for sinus   *
 * and tan for tangent.                                   *
 *********************************************************/
  void level5(double *result) {
    register char op[5];
    strcpy(op,"");;
    if((tok_type==DELIMITER) && (is_in(*token,"+-acelprst"))) {
      strcpy(op,token);
      get_token();
    }
    // no argument for the constant pi
    if (op[0]!='p') level6(result);
    if (strlen(op)>0) unary(op,result);
  }

 /******************************************
 *     Expression with parentheses         *
 * --------------------------------------- *
 * Recursive treatment from outside to     *
 * inside.                                 *
 ******************************************/
  void level6(double *result)  {
    if((*token=='(') && (tok_type==DELIMITER)) {
      get_token();
      level2(result);
      if(*token != ')') serror(1); // wrong number of parentheses !
      get_token();
    }
    else primitive(result);  // evaluate final result
  }

 /**************************************************
 *     Actual value of a number or a variable      *
 * A variable is evaluated by its formula, if it   *
 * exists, by calling find_var() that returns zero *
 * by default (be careful with divisions!).        *
 * A number is evaluated by calling the standard   *
 * C library function atof().                      *
 **************************************************/
  void primitive(double *result) {
    switch(tok_type) {
    case VARIABLE :
      *result=find_var(token);
      get_token();
      return;
    case NUMBER :
      *result=atof(token);
      get_token();
      return;
    default :
      serror(0);  //syntax error message
    }
  }

/****************************
 * Arithmetical operations  *
 * ------------------------ *
 *  ^ : power operator      *
 *  % : modulo operator     *
 ***************************/
  void arith(char o, double *r, double *h) {
    register double t;
    switch(o) {
      case '-': *r=*r-*h; break;
      case '+': *r=*r+*h; break;
      case '*': *r=*r**h; break;
      case '/': if (*h!=0) *r=(*r)/(*h);
		else { serror(3); ok=0; } break;
      case '%': t=(*r)/(*h); *r=*r-(t*(*h)); break;
      case '^': *r=pow(*r,*h);
    }
  }

 /**************************************
 *  Process a unary operation:         *
 *  - before a number or a function.   *
 *  Called by level5().                *
 **************************************/
  void unary(char *o, double *r) {
    if(o[0]=='-') *r=-(*r);
    else if (strcmp(o,"acos")==0) *r=acos(*r);
    else if (strcmp(o,"asin")==0) *r=asin(*r);
    else if (strcmp(o,"atan")==0) *r=atan(*r);
    else if (strcmp(o,"cos")==0) *r=cos(*r);
    else if (strcmp(o,"exp")==0 || o[0]=='e') *r=exp(*r);
    else if (strcmp(o,"log")==0)
	    if (*r>0) *r=log10(*r);
	    else { serror(4); ok=0; }
    else if (strcmp(o,"ln")==0)
	    if (*r>0) *r=log(*r);
	    else { serror(5); ok=0; }
    else if (strcmp(o,"pi")==0)  *r=4.0*atan(1.0);
    else if (strcmp(o,"root")==0 || o[0]=='r') if (*r>=0) *r=sqrt(*r);
		else { serror(6); ok=0; }
    else if (strcmp(o,"sin")==0) *r=sin(*r);
    else if (strcmp(o,"tan")==0) if (fabs(*r-PI/2)>1e-10) *r=tan(*r);
				 else { serror(7); ok=0; }
  }

 /************************************************
 * Finds the value of a variable by using its    *
 * formula, if it exists, else returns zero.     *
 * Called by primitive().                        *
 ************************************************/
double find_var(char *s)  {
  int i,n;
  char *q;
  double valeur;

  if (!isalpha(*s)) {
    serror(0); // the variable is not alphanumerical
    return 0;
  }
  // seek the variable number
  n=-1;
  for (i=1; i<NB_VAR; i++)
    if ((vrbl[i]) && (strcmp(s,vrbl[i])==0)) n=i;
	if (n==-1) {            // case new variable
    num++;                  // num can go from 0 to NB_VAR-1
    vrbl[num]= (char *) malloc(40);   // dynamic allocation
    strcpy(vrbl[num],s);              // of 40 bytes.
    n=num;
  }
  if (formule[n]) {       // a formula with this number already exists
    q=prog;               // current computation is saved in q
    prog=formule[n];
    calcule_exp(&valeur); // calculate the variable with its formula
    prog=q;               // restore current computation
    if ((!flg[n]) && (n))
      printf("  %s=%.8f\n",vrbl[n],valeur);
    flg[n]=1;             // inhibit message for this variable
    return valeur;        // current value of the variable
  }
  if ((!flg[n]) && (n))
    printf("  No formula or assignation for variable %s.\n", vrbl[n]);
  flg[n]=1;
  return 0;                // no assignated value
}

// display syntax error or other
  void serror(int n) {
    printf("  %s\n",ERR[n]);
    ok=0;     // inhibit display of result, if error
  }

 /************************************************
 * Divide up the input string into its elements  *
 *   ( delimiter=1, variable=2 and number=3 )    *
 * --------------------------------------------- *
 * Example:  let us analyze the expression       *
 *           Masse+100-(Base*S)/2                *
 * The successive calls to get_token() will give *
 * the following results:                        *
 *        token         tok_type                 *
 *        -----         --------                 *
 *        Masse         VARIABLE                 *
 *          +           DELIMITER                *
 *         100           NUMBER                  *
 *          -           DELIMITER                *
 *          (           DELIMITER                *
 *         Base         VARIABLE                 *
 *          *           DELIMITER                *
 *          S           VARIABLE                 *
 *          )           DELIMITER                *
 *          /           DELIMITER                *
 *          2            NUMBER                  *
 *         null           null                   *
 ************************************************/
  void get_token()
  {
    int m,end=0;
    register char c,*temp;
    tok_type=0;
    temp=token;
    while(isspace(*prog)) ++prog; // skip blanks
    // case delimiter (basic operator or function)
    if(is_in(*prog,"+-*/%^=()acelprst")) {
      tok_type=DELIMITER;
      if (is_in(*prog,"acelprst")) {   // case function
	c=*prog;
	switch(c) {     // end= number of characters in function name
	  case 'a': end=4; break;               // acos, asin, atan
	  case 'l': if (*++prog=='n') end=2; else end=3;
		    *prog--; break;                     // ln ou log
	  case 'p': end=2; break;                   // constant pi
      case 'r': end=4; break;                   // root
	  default : end=3;     // usual case of a 3 letters function (cos,sin,tan, etc.)
	}
	for (m=1; m<end+1; m++) *temp++=*prog++;
      }
      else *temp++ = *prog++; // go to next position
    }
    // case variable name
    else if(isalpha(*prog)) {
      while((!is_in(*prog,"+-*/%^=()")) && (*prog!=0))
	*temp++ = *prog++;
      tok_type=VARIABLE;
    }
    // case number
    else if(isdigit(*prog)) {
      while(!isdelim(*prog)) *temp++ = *prog++;
      tok_type=NUMBER;
    }
    *temp='\0';
  }

// returns 1=true if c is a delimiter: +-* /%^=()acelprst
  int isdelim(char c)  {
    if(is_in(c,"+-*/%^=()acelprst") || c==9 || c=='\r' || c==0)
      return 1;
    return 0;
  }

// returns true if ch is included in string s
  int is_in(char ch, char *s) {
    while(*s) if(*s++==ch) return 1;
    return 0;
  }

  /****************************************************************
  * Stores a formula A...= to Z...= and returns a flag (0= no     *
  * assignation ) or (1=assignation OK) to function exec_calcul() *
  * with no result display when the assignation is OK.            *
  * ------------------------------------------------------------- *
  * Example:  if Weight=Mass*G is the first declaration,          *
  *           formule[0] contains the string Weight*G             *
  * The instruction Weight triggers the calculation  Weight*G and *
  * displays the numerical result (or the use of Weight in another*
  * expression or assignation).                                   *
  * ------------------------------------------------------------- *
  * NOTE - Replaces the less sophisticated function level1() of   *
  *        version 1 which only kept a numerical value and not a  *
  *        litteral formula.                                      *
  ****************************************************************/
  int get_formula()
  {
    int egal,i,r;
    char c[2],nom[40]="";
	c[0]='y';
    egal=0;
    /* recherche d'un signe = */
    for (i=0; i<strlen(prog); i++)
      if (prog[i]=='=') {
        egal=1;
        r=i;
	    strncpy(nom,prog,r);
      }
    if (egal) {   // prog contains the sign =
      indice=-1;
      // seek an existing variable
      for (i=1; i<NB_VAR; i++)
	    if ((vrbl[i]) && (strcmp(nom,vrbl[i])==0)) indice=i;
      // case of a new variable
      if (indice==-1) {
        num++;
	    if (!vrbl[num]) vrbl[num]= (char *) malloc(40);
	    strcpy(vrbl[num],nom);
        indice=num;
      }
      if (!formule[indice]) formule[indice]= (char *) malloc(40);
      else {   // the formula already exists
	    printf("  Formula: %s\n",formule[indice]);
	    printf("  Confirm request (y/n): ");
	    scanf("%s",c); printf("\n");
      }
      // detect a dynamic allocation failure
      if((!formule[indice]) || (!vrbl[indice])) {
	    serror(8); // memory full !
	    scanf("%s",c);
	    exit(1);
      }
      // copy right member in formule[indice]
	  // if authorization is ok.
      if (c[0]=='y')
	    for (i=0; i<strlen(prog); i++)
	      formule[indice][i]=prog[i+r+1];
      return 1; // assignation Ok
    }
    return 0;   // no assignation
  }

  /************************
  *   option calculate    *
  ************************/
  void exec_calcul() {
    char *p;
    int i,k,found;
    // the string to evaluate is limited to 140 characters
    p=(char *) malloc(140);
    if(!p) {
      serror(8); // memory full !
      exit(1);
    }
    // the variable Answer always contains the previous calculation
    vrbl[0]= (char *) malloc(40);
    formule[0]= (char *) malloc(40);
    strcpy(vrbl[0],"Answer");
    // accept expressions so long as a blank line is not found
    //clrscr();       erase screen (MSDOS only)
    printf("\n\n   *** CALCULATE (q to exit) ***\n\n");
    // main loop of exec_calcul()
    do {
      i=0;  // flag 0=calculation asked for  1=assignation only
      ok=1; //  "   0=no display of result   1=display result
      printf("\n  ");
      prog=p;
      scanf("%s", prog);     // input calculation to be executed
	  if (strcmp(p,"q")==0) {free(p); return;} //normal return 
      // case of linked calculations
      if (is_in(prog[0],"+-*/%^")) {
	    strcat(bak,prog);
	    strcpy(prog,bak);
      }
      else 
		strcpy(bak,prog);            // copy prog into bak
      i=get_formula();               // treat assignation
      found=0;
      // detect a variable name instruction
      // if the variable has no formula or no
      // assigned value, return 0 with message
      for (k=0; k<NB_VAR; k++)
        if (vrbl[k] && (strcmp(prog,vrbl[k])==0)) {
          found=1;   // the variable exists
          indice=k;
        }
      if (found)
	  if (formule[indice]) {   // the formula is valid
	    for(k=0; k<NB_VAR; k++) flg[k]=0;
	    strcpy(prog,formule[indice]);
	    if (indice) printf("  Formula: %s\n",prog);
      }
      if (i==0) {    // the calculation is  allowed
	    calcule_exp(&answer);
	    if (ok) {    // display is allowed
	      printf("  %.8f\n",answer);
	      // store result in variable Answer
		  gcvt(answer,15,formule[0]);
	      strcpy(bak,formule[0]);
		}
	    else 
	      strcpy(bak,""); // no more previous expression
      }
    } while(strcmp(p,"q")!=0);
  }

  /*************************************
  * option List variables and formulas *
  *************************************/
  void list_var()
  {
    int i;
    printf("\n                    *** VARIABLES LIST ***\n");
    printf("\n           Variable                         Formula or value\n");
    printf("           --------                         ----------------\n");
    for (i=1; i<num+1; i++)
      if (vrbl[i]) printf("    %15s       %40s\n",vrbl[i],formule[i]);
    getchar();
  }

  int read_session()
  {
    int i,n=0,nb;
    char snb[4], var[40], form[40];
    printf("\n      *** READ A SESSION ***\n");
    if (strlen(nom_in)==0) strcpy(nom_in,"calcul.asc");
    if ((fp_in=fopen(nom_in,"r"))==NULL) {
      printf("\n  Read: impossible to open file %s\n",nom_in);
      exit(1);
    }
    // nb= number of items to be read
    fscanf(fp_in," %s",snb);
    nb=atoi(snb);
    for (i=0; i<nb+1; i++) {
      strcpy(var,""); strcpy(form,"");
      fscanf(fp_in,"  %s  %s",var,form);
      if (strlen(var)>0) {
	n++;
	vrbl[n]= (char *) malloc(40);
	if (!vrbl[n]) { serror(8); exit(1); }
	strcpy(vrbl[n],var);
	formule[n]= (char *) malloc(40);
	if (!vrbl[n]) { serror(8); exit(1); }
	strcpy(formule[n],form);
      }
    }
    fclose(fp_in);
    printf("  Number of items read: %d\n",n);
    getchar();
    return n;
  }

  /**************************
  *  option save a session  *
  **************************/
  void save_session()
  {
    int i;
    //clrscr();
    printf("\n     *** SAVE A SESSION ***\n");
    if (strlen(nom_out)==0) strcpy(nom_out,"calcul.asc");
    if ((fp_out=fopen(nom_out,"w"))==NULL) {
      printf("\n  Save: impossible to open file %s\n",nom_out);
      exit(1);
    }
    fprintf(fp_out,"  %d\n",num);
    for (i=1; i<num+1; i++)
      if (vrbl[i]) fprintf(fp_out,"  %s  %s\n",vrbl[i],formule[i]);
    fclose(fp_out);
  }

  //write n blank lines to screen
  void clear_screen(int n) {
    int i;
    for (i=0; i<n; i++)
      printf("\n");
  }

  // main menu
  void menu()
  {
    clear_screen(2);
    puts("        ***********************************************");
    puts("        *                 PARSER                      *");
    puts("        *                                             *");
    puts("        *   Display variables and formulas     :  d   *");
    puts("        *   Make calculations                  :  m   *");
    puts("        *   Read a previous session from a file:  r   *");
    puts("        *   Save a session to an output file   :  s   *");
    puts("        *   Suppress a variable                :  x   *");
    puts("        *   ---------------------------------------   *");
    puts("        *   Quit parser                        :  q   *");
    puts("        *                                             *");
    puts("        ***********************************************");
    printf("              Your choice (d, m, r, s or q): ");
    scanf("%s", choice);
	clear_screen(2);
  }

  // save session before exit ?
  void question() {
    char c[2];
    printf("\n\n         Do you want to save your session (y/n): ");
    scanf("%s", c);
    if (c[0]=='y') save_session();
  }

  void suppress_var() {
    char nom[40];
    int i,ind;
    //clrscr();
    printf("\n       *** SUPPRESS A VARIABLE ***\n");
    printf("\n  Name of the variable to suppress: "); gets(nom);
    // seek number of existing variable
    for (i=1; i<num+1; i++)
      if ((vrbl[i]) && (strcmp(nom,vrbl[i])==0)) ind=i;
    for (i=ind; i<num+1; i++) {
      strcpy(vrbl[i],vrbl[i+1]);
      strcpy(formule[i],formule[i+1]);
    }
    printf("  Suppression done.\n");
    free(vrbl[num+1]);
    free(formule[num+1]);
    num--;
  }

  void main()  {
    int i;
	//name of default input file
    strcpy(nom_in,"calcul.txt");
	//name of default output file
    strcpy(nom_out,"calcul.txt");
    do {
      menu();     // call main menu
      switch(choice[0]) {
	    case 'd': list_var(); break;
        case 'm': exec_calcul(); break;
	    case 'r': num=read_session(); break;
	    case 's': save_session(); break;
	    case 'x': suppress_var(); break;
	    case 'q':   // exit program
		question(); // want to save ?
		for (i=0; i<num+1; i++) {          //free memory
		 if (formule[i]) free(formule[i]);
		 if (vrbl[i]) free(vrbl[i]);
		}
		printf("\n");
		exit(0); // normal exit
      }
    } while (choice[0]!='q');
  }

// end of file parser.cpp (last update: 08/21/2002)