// Written for undergraduate C++ course project at Dept of
// Computer Science, Rutgers University.

//extern "C" {
// char *strcpy(char *nam, char *str);
// }

typedef char * strng;

/* class expr is the top of the class heirarchy for expressions. Any
   expression object will be an instance of some derived class which has
   class expr as its base class (or as the base class of its base class...)
*/
class expr {
 public:
  expr(){}
  ~expr(){}
  virtual void print_me()     = 0;

     /* This is the function that an expression object uses to print itself.
      The version given here should never be run - the print function should
      be redefined in the derived class */

  virtual expr *deriv(char *var)  = 0;
     /* This is the function that an expression object uses to compute its
      derivative with respect to "var". The version given here should never
      be run - deriv() should be redefined in the derived class */

  virtual double eval(double at)  = 0;
   /* This is the function that an expression object uses to compute its
      value when all variables in it are replaced by the value of "at"
      */

  virtual int isconst() = 0;
   /* This is the function that can be used to determine if an expression
      is a constant. */
};
     
     
/* an expression which is a numerical constant */
class const_expr : public expr {
  double value;
 public:
  const_expr(double v) {value = v;}
  ~const_expr(){}
  void print_me() {cout << " " << value << " ";}
  double eval(double at);
  expr *deriv(strng var);
  int isconst()
    {
      return(1); // if the expression is a const this funtion will return true.
    }
 };

/* an expression which is a single variable */
class var_expr : public expr {
private:
  char name[30];
 public:
  var_expr(strng str) {strcpy(name,str);} /* Copy the initialization string
                       into the name buffer. To read the documentation for
                       strcpy() and other C string manipulation functions,
                       type the Unix shell command "man string" */
  ~var_expr(){}
  void print_me()  {cout << " " << name << " ";}
  double eval(double at);
  expr *deriv(strng var);
  int isconst()
  {
    return(0); // if the expression is a variable this functions returns false.
  }
};

/* expression resulting from applying a binary operator to two expressions */
class bin_op_expr : public expr {
 public:
  bin_op_expr(expr *e1, expr *e2) {first = e1; second = e2;}
  ~bin_op_expr(){}
  void print_me();
  int isconst()
  {
    return(0); // if the expression is a bin_op this function return false.
  }
 protected:
  expr *first;
  expr *second;
  char op_name;
 };

/* an expression which is the sum of two expressions */
class sum_expr : public bin_op_expr {
 public:
  sum_expr(expr *e1, expr *e2) : bin_op_expr(e1,e2) {op_name = '+';}
  ~sum_expr(){}
  double eval(double at);
  expr *deriv(strng var);
 };

/* an expression which is the product of two expressions */
class prod_expr : public bin_op_expr {
 public:
  prod_expr(expr *e1, expr *e2) : bin_op_expr(e1,e2) {op_name = '*';}
  ~prod_expr(){}
  double eval(double at);
  expr *deriv(strng var);
 };

/* an expression which is the quotient of two expressions */
class quotient_expr : public bin_op_expr {
 public:
  quotient_expr(expr *e1, expr *e2) : bin_op_expr(e1,e2) {op_name = '/';}
  ~quotient_expr(){}
  double eval(double at);
  expr *deriv(strng var);
 };