---

exprparser.h

Go to the documentation of this file.

#ifndef ___EXPRPARSER_H___
#define ___EXPRPARSER_H___

#include <stdio.h>
#include <string>
using std::string;

#include "../src/msg.h"
#include "../src/polymorph.h"



template <class T=int>
class ExprParser {
public:
  ExprParser(const char* expr, Msg::LevelHandler<>** mhp_i=&(Msg::LevelHandler<>::default_instance()))
    : remaining(expr)  {  mhp = mhp_i;  };

  virtual ~ExprParser() { }



  double       cmdf() {  return (double)read_float();  }
  
  long         cmdi() {
    exprtype result = read_float();
    if (result >= INT_MAX || result <= INT_MIN)
      message(Msg::Warning,"Value " + String::stringrep(double(result)) +
              " outside the representable range of an integer (" +
              String::stringrep(INT_MIN) + "," + String::stringrep(INT_MAX) +
              "); may cause overflow or underflow");
    
    return (long)(floor(0.5+result));
  }
  
  const char * cmds() {  return getstringval();  }

  bool consumeifpresent(string s) {
    if (strncmp(s.c_str(), remaining, s.length()) == 0) {
      remaining += s.length();
      return true;
    }
    return false;
  }

  string whatsleft() {  return string(remaining);  }
  
  bool empty() const {  return (*remaining==0);  }
  
  static void message(Msg::MessageLevel m, const string& s)
    {  if (mhp && *mhp) (**mhp)(m,s);  }
  
  typedef
#ifndef LONG_DOUBLE_UNAVAILABLE
  long
#endif
  double exprtype;

  exprtype        getnumericval();

protected:
  virtual const Typeless& getval();
  const char*     remaining;

private:
  virtual const char* getstringval();
  exprtype        read_float(bool warn=true);
  exprtype        apply_op(exprtype lval, string op, exprtype rval);
  exprtype        next_term(string previous_op="");
  string          next_op();
  exprtype        parse_expr();
  int             op_has_precedence(const string& previous_op, const string& op);
  static Msg::LevelHandler<>** mhp;
};

/* Static variables */
template <class T>
Msg::LevelHandler<>** ExprParser<T>::mhp=&(Msg::LevelHandler<>::default_instance());


template <class T>
const Typeless& ExprParser<T>::getval()
{
  const char* str = remaining;
  char *rem;
  static Polymorph<double> numval(0.0);
  numval = strtod(str,&rem);
  remaining = rem;

  if (str == remaining) {
    while (*remaining && (*remaining != ')'))
      remaining++;  /* Skip this item */
    message(Msg::Error,"Can't parse expression: `" + string(str) + "'");
    numval=-1;
  }
  
  return numval;
}



template <class T>
const char *ExprParser<T>::getstringval()
{
  const size_t bufsize=65536; // Arbitrary limit
  static char buf[bufsize];
  const char* maxbufptr=buf+bufsize;

  char* bufptr=buf;

  while (remaining && *remaining && bufptr<maxbufptr) {
    /* Copy all characters directly */
    while (*remaining && bufptr<maxbufptr)
      *(bufptr++) = *(remaining)++;
  }
  if (bufptr>=maxbufptr)
    message(Msg::Error,"Reached maximum string size; characters may be lost");
  
  *bufptr='\0';
    
  return buf;
}



template <class T>
typename ExprParser<T>::exprtype ExprParser<T>::getnumericval()
{
  const char* str = remaining;
  
  if (*remaining == '(') {
    exprtype subexpr;
    (remaining)++;    
    subexpr=(parse_expr());
    
    if (*remaining != ')')
      message(Msg::Error,"Missing right parenthesis");
    else
      (remaining)++;
    return subexpr;
  }

  if (*remaining == '-') {
    (remaining)++;        
    return -1.0*next_term();
  }
  
  const Typeless& val = getval();
  if (val.isnumeric())
    return val.numericvalue();
  else
    message(Msg::Error,"Invalid param type in expression `" + string(str) + "'");
 
  return Uninitialized;
}



template <class T>
typename ExprParser<T>::exprtype ExprParser<T>::apply_op(exprtype lval, string op, exprtype rval)
{
  if      (op == "+")  return lval +  rval;
  else if (op == "-")  return lval -  rval;
  else if (op == "*")  return lval *  rval;
  else if (op == "<")  return lval <  rval;
  else if (op == ">")  return lval >  rval;
  else if (op == "==") return lval == rval;
  else if (op == "!=") return lval != rval;
  else if (op == "<=") return lval <= rval;
  else if (op == ">=") return lval >= rval;
  else if (op == "<?") return std::min(lval,rval);
  else if (op == ">?") return std::max(lval,rval);
  else if (op == "@;") return lval * sin(rval); /* Appallingly bad notation! */
  else if (op == "@:") return lval * cos(rval); /* Appallingly bad notation! */
  
  else if (op == "%" || op == "/") {
    if (rval==0) {
      message(Msg::Error,"Division by zero");
      return Uninitialized;
    }
    if (op == "/") return lval / rval;
    else           return fmod(lval,rval);
  }
  
  message(Msg::Error,"Unknown operator " + op);
  return Uninitialized;
}



template <class T>
int ExprParser<T>::op_has_precedence(const string& previous_op, const string& op)
{
  (void) previous_op; /* Currently ignored */
  return (op=="*" || op=="/" | op=="%");
}



template <class T>
string ExprParser<T>::next_op()
{
  const char* start=remaining;

  while (ispunct(*remaining) && !(*remaining=='(') && !(*remaining==':' && *(remaining+1)==':'))
    (remaining)++;

  const char* end=remaining;

  return string(start,end-start);
}



template <class T>
typename ExprParser<T>::exprtype ExprParser<T>::next_term(string previous_op)
{
  exprtype lval = getnumericval();
  string op = next_op();
  
  /* Reduce strings of operators with precedence */
  while (op_has_precedence(previous_op, op)) {
    if (! *remaining) {
      message(Msg::Error,"Missing right value in `" + string(remaining) + "'");
      return lval;
    }
    lval=apply_op(lval,op,getnumericval());
    previous_op = op;
    op = next_op();
  }
  remaining -= op.length(); /* Push back unused operator */

  return lval;
}



template <class T>
typename ExprParser<T>::exprtype ExprParser<T>::parse_expr()
{
  const char* str = remaining;
  exprtype lval = next_term();

  while (*remaining && *remaining != ')') {
    string op= next_op();
    
    if (! *remaining) {
      message(Msg::Error,"Missing right value in `" + string(str) + "'");
      return lval;
    }
    
    lval = apply_op(lval,op,next_term(op));
  }

  return lval;
}



template <class T>
typename ExprParser<T>::exprtype ExprParser<T>::read_float(bool warn)
{
  const char* str = remaining;
  exprtype val = parse_expr();

  if (str == remaining) {
    message(Msg::Error,"No number found in string: `" + string(str) + "'");
    return Uninitialized;
  }
  
  if (warn && *remaining)
    message(Msg::Warning,"Trailing characters in expression ignored: `" + string(remaining) + "'");
  return val;
}



#endif /* ___EXPRPARSER_H___ */

---