JBLParserResult.C

Go to the documentation of this file.

#include "jbltools/sfh/JBLParserResult.h"
#include "jbltools/sfh/IntFun.h" 
#include "jbltools/sfh/FloatFun.h" 
#include "jbltools/sfh/BaseCut.h" 

#include <iostream>             
#include <sstream>     
#include <map>
        
using namespace std;

static const char *ident="@(#)$Id: JBLParserResult.C,v 1.11 2005/07/21 11:20:12 blist Exp $";

    typedef std::map<std::string, JBLParserResult::Fun_f_f     > Map_f_f     ;
    typedef std::map<std::string, JBLParserResult::Fun_f_f_f   > Map_f_f_f   ;
    typedef std::map<std::string, JBLParserResult::Fun_f_f_i   > Map_f_f_i   ;
    typedef std::map<std::string, JBLParserResult::Fun_i_i     > Map_i_i     ;
    typedef std::map<std::string, JBLParserResult::Fun_b_b     > Map_b_b     ;
    typedef std::map<std::string, JBLParserResult::Fun_FF_FF   > Map_FF_FF   ;
    typedef std::map<std::string, JBLParserResult::Fun_FF_FF_FF> Map_FF_FF_FF;
    typedef std::map<std::string, JBLParserResult::Fun_FF_FF_IF> Map_FF_FF_IF;
    typedef std::map<std::string, JBLParserResult::Fun_IF_IF   > Map_IF_IF   ;
    typedef std::map<std::string, JBLParserResult::Fun_BC_BC   > Map_BC_BC   ;
    
    static Map_f_f      *theMap_f_f     = 0;
    static Map_f_f_f    *theMap_f_f_f   = 0;
    static Map_f_f_i    *theMap_f_f_i   = 0;
    static Map_i_i      *theMap_i_i     = 0;
    static Map_FF_FF    *theMap_FF_FF   = 0;
    static Map_FF_FF_FF *theMap_FF_FF_FF= 0;
    static Map_FF_FF_IF *theMap_FF_FF_IF= 0;
    static Map_IF_IF    *theMap_IF_IF   = 0;

JBLParserResult::JBLParserResult()
: type (EMPTY), 
  intvalue(0), floatvalue(0), boolvalue(false),
  intfunvalue (0), floatfunvalue (0), basecutvalue (0),
  name("EMPTY"), next (0)
{}
JBLParserResult::JBLParserResult(int       intvalue_)
: type (INT), 
  intvalue(intvalue_), floatvalue(intvalue_), boolvalue(false),
  intfunvalue (0), floatfunvalue (0), basecutvalue (0),
  name(NamedO::str(intvalue_)), next (0)
{}
JBLParserResult::JBLParserResult(Float_FF     floatvalue_)
: type (FLOAT), 
  intvalue(0), floatvalue(floatvalue_), boolvalue(false),
  intfunvalue (0), floatfunvalue (0), basecutvalue (0),
  name(NamedO::str(floatvalue_)), next (0)
{}
JBLParserResult::JBLParserResult(bool      boolvalue_)
: type (BOOL), 
  intvalue(0), floatvalue(0), boolvalue(boolvalue_),
  intfunvalue (0), floatfunvalue (0), basecutvalue (0),
  name(NamedO::str(boolvalue_)), next (0)
{}
JBLParserResult::JBLParserResult(IntFun   &intfunvalue_)
: type (INTFUN), 
  intvalue(0), floatvalue(0), boolvalue(false),
  intfunvalue (&intfunvalue_), floatfunvalue (0), basecutvalue (0),
  name(intfunvalue_.getName()), next (0)
{}
JBLParserResult::JBLParserResult(FloatFun &floatfunvalue_)
: type (FLOATFUN), 
  intvalue(0), floatvalue(0), boolvalue(false),
  intfunvalue (0), floatfunvalue (&floatfunvalue_), basecutvalue (0),
  name(floatfunvalue_.getName()), next (0)
{}
JBLParserResult::JBLParserResult(BaseCut  &basecutvalue_)
: type (BASECUT), 
  intvalue(0), floatvalue(0), boolvalue(false),
  intfunvalue (0), floatfunvalue (0), basecutvalue (&basecutvalue_),
  name(basecutvalue_.getName()), next (0)
{}
JBLParserResult::JBLParserResult(const string& name_)
: type (IDENTIFIER), 
  intvalue(0), floatvalue(0), boolvalue(0),
  intfunvalue (0), floatfunvalue (0), basecutvalue (0),
  name(name_), next (0)
{}


JBLParserResult& JBLParserResult::addCopyToList(const JBLParserResult &rhs)
{
  name += ", "+rhs.name;
  JBLParserResult *p = this;
  while (p->next) p = p->next;
  p->next = new JBLParserResult(rhs);
  return *this;
}

JBLParserResult::JBLParserResult(const JBLParserResult &rhs)
: type (rhs.type), 
  intvalue(rhs.intvalue), floatvalue(rhs.floatvalue), boolvalue(rhs.boolvalue),
  intfunvalue (rhs.intfunvalue), floatfunvalue (rhs.floatfunvalue), basecutvalue (rhs.basecutvalue),
  name(rhs.name), next (rhs.next ? new JBLParserResult(*rhs.next) : 0)
{
  // cout << "JBLParserResult::JBLParserResult: just copied " << rhs << endl;
  // for (JBLParserResult *p = next; p; p=p->next) cout << "  followed by " << *p << endl;
}

JBLParserResult& JBLParserResult::operator= (const JBLParserResult &rhs) {
  if (this == &rhs) return *this;
  JBLParserResult *oldnext = next;
  next = 0;
  type =rhs.type; 
  intvalue=rhs.intvalue; 
  floatvalue=rhs.floatvalue; 
  boolvalue=rhs.boolvalue;
  intfunvalue =rhs.intfunvalue; 
  floatfunvalue =rhs.floatfunvalue;
  basecutvalue =rhs.basecutvalue;
  name=rhs.name;
//   if (rhs.next) { 
//     cout << "JBLParserResult::operator=: will copy " << *rhs.next << endl;
//     if (rhs.next->next) cout << "...which is followed by " << *rhs.next->next << endl;
//   }
  next = rhs.next ? new JBLParserResult(*rhs.next) : 0;
  delete oldnext;
  return *this;
}

JBLParserResult::~JBLParserResult()
{ 
//   if (next) { 
//     cout << "JBLParserResult::~JBLParserResult=: will delete " << *next << endl;
//     if (next->next) cout << "...which is followed by " << *(next->next) << endl;
//   }
  // cout << "~JBLParserResult: deleting " << name << "\n";
  delete next;
  next = 0;
}

int  JBLParserResult::listlength() const    {
  int result = 0;
  for (const JBLParserResult *p = this; p && !p->isEmpty(); p=p->next, result++);
  return result;
}
    
int    JBLParserResult::getIntValue() const {
  if (isInt()) return intvalue;
  return 0;
}
Float_FF  JBLParserResult::getFloatValue() const {
  if (isFloat()) return floatvalue;
  if (isInt())   return intvalue;
  return 0;
}
bool   JBLParserResult::getBoolValue() const {
  if (isBool()) return boolvalue;
  return 0;
}

IntFun   *JBLParserResult::getIntFunValue() const {
  if (isIntFun()) return intfunvalue;
  if (isInt()) return new ConstIntFun(intvalue);
  return 0;
}
FloatFun *JBLParserResult::getFloatFunValue() const {
  if (isFloatFun()) return floatfunvalue;
  if (isIntFun()) return &Float(*intfunvalue);
  if (isNumber()) return new ConstFun(getFloatValue());
  return 0;
}
BaseCut  *JBLParserResult::getBaseCutValue() const {
  if (isBaseCut()) return basecutvalue;
  if (isBool()) return new ConstBaseCut (boolvalue);
  return 0;
}

JBLToken JBLParserResult::token;

JBLParserResult JBLParserResult::parseExpression (const std::string& input) {
  istringstream is (input);
  token.input(is);
  return expression (is);
}

JBLParserResult JBLParserResult::parseExpression (std::istream& is) {
  token.input(is);
  return expression (is);
}

template <class T1, class T2>  
JBLParserResult JBLParserResult::comparison (int op, const T1& lhs, const T2& rhs) {
   switch (op) {
     case 0: return JBLParserResult (lhs == rhs);
     case 1: return JBLParserResult (lhs != rhs);
     case 2: return JBLParserResult (lhs <  rhs);
     case 3: return JBLParserResult (lhs <= rhs);
     case 4: return JBLParserResult (lhs > rhs); 
     case 5: return JBLParserResult (lhs >= rhs);
     case 6: return JBLParserResult (lhs + rhs);
     case 7: return JBLParserResult (lhs - rhs);
     case 8: return JBLParserResult (lhs *  rhs);
     case 9: return JBLParserResult (lhs / rhs);
   }
  return syntaxError ("comparison: Unknown operator!");
}

JBLParserResult JBLParserResult::makefloatfunction (const std::string& fname, JBLParserResult& arglist) { 
  if (arglist.listlength()==1) {
    JBLParserResult& arg = arglist;
    if (arg.isInt()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_i_i\n";
      Map_i_i::iterator it = theMap_i_i->find(fname);
      if (it != theMap_i_i->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(arg.getIntValue()));
      }
    }
    if (arg.isNumber()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_f_f\n";
      Map_f_f::iterator it = theMap_f_f->find(fname);
      if (it != theMap_f_f->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(arg.getFloatValue()));
      }
    }
    if (arg.isIntFun()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_IF_IF\n";
      Map_IF_IF::iterator it = theMap_IF_IF->find(fname);
      if (it != theMap_IF_IF->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(*arg.getIntFunValue()));
      }
    }
    if (arg.isFloatFun()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_FF_FF\n";
      Map_FF_FF::iterator it = theMap_FF_FF->find(fname);
      if (it != theMap_FF_FF->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(*arg.getFloatFunValue()));
      }
    }
    std::string error ("makefloatfunction: Cannot generate function '");
      error += fname+"' with argument '" + arg.getName() + "' of type " + NamedO::str((int)arg.type) + "!";
    return syntaxError (error);
  }
  else if (arglist.listlength()==2) {
    JBLParserResult& arg1 = arglist;
    JBLParserResult& arg2 = *arglist.next;
    assert (&arg2);
    if (arg1.isNumber() && arg2.isInt()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_f_f_i\n";
      Map_f_f_i::iterator it = theMap_f_f_i->find(fname);
      if (it != theMap_f_f_i->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(arg1.getFloatValue(), arg2.getIntValue()));
      }
    }
    if (arg1.isNumber() && arg2.isNumber()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_f_f_f\n";
      Map_f_f_i::iterator it = theMap_f_f_f->find(fname);
      if (it != theMap_f_f_f->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(arg1.getFloatValue(), arg2.getFloatValue()));
      }
    }
    if (arg1.isFloatFun() && arg2.isIntFun()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_FF_FF_IF\n";
      Map_FF_FF_IF::iterator it = theMap_FF_FF_IF->find(fname);
      if (it != theMap_FF_FF_IF->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(*arg1.getFloatFunValue(), *arg2.getIntFunValue()));
      }
    }
    if (arg1.isFloatFun() && arg2.isFloatFun()) {
      std::cout << "makefloatfunction: looking for " << fname << " in theMap_FF_FF_FF\n";
      Map_FF_FF_FF::iterator it = theMap_FF_FF_FF->find(fname);
      if (it != theMap_FF_FF_FF->end()) {
        std::cout << "  ...found!\n";
        return JBLParserResult ((*it->second)(*arg1.getFloatFunValue(), *arg2.getFloatFunValue()));
      }
    }
  }
  std::string error ("makefloatfunction: Cannot generate function '");
    error += fname+"' with arguments '" + arglist.getName() + "'!";
  return syntaxError (error);
}

JBLParserResult JBLParserResult::expression (istream& is) {
  return assignment_expression (is);
}

JBLParserResult JBLParserResult::assignment_expression (istream& is) {
  return conditional_expression (is);
}

JBLParserResult JBLParserResult::conditional_expression (istream& is) {
  return logical_OR_expression (is);
}


JBLParserResult JBLParserResult::logical_OR_expression (istream& is) {
  // cout << "logical_OR_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = logical_AND_expression(is);
  while (token.isOperator() && token.getStringValue() == "||") {
    token.input(is);
    JBLParserResult rhs = logical_AND_expression(is);
    
    if (lhs.isBaseCut()) {
      BaseCut& lhsval (*lhs.getBaseCutValue());
      if (rhs.isBaseCut()) {
        BaseCut& rhsval (*rhs.getBaseCutValue());
        lhs = JBLParserResult (lhsval || rhsval);
      }
//       else if (rhs.isBool()) {
//         bool rhsval = rhs.getBoolValue();
//         lhs = JBLParserResult (lhsval || rhsval); break;
//       }
    }
    else if (lhs.isBool()) {
      bool lhsval = lhs.getBoolValue();
//       if (rhs.isBaseCut()) {
//         BaseCut& rhsval (*rhs.getBaseCutValue());
//         lhs = JBLParserResult (lhsval || rhsval); break;
//       }
//       else 
      if (rhs.isBool()) {
        bool rhsval =rhs.getBoolValue();
        lhs = JBLParserResult (lhsval || rhsval); 
      }
    }
    else {
      cerr << "JBLParserResult::logical_OR_expression: cannot OR '" << lhs.name << "' and '" 
           << rhs.name << "'!\n";
    }
  }
  // cout << "   logical_OR_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::logical_AND_expression (istream& is) {
  // cout << "logical_AND_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = inclusive_OR_expression(is);
  while (token.isOperator() && (token.getStringValue() == "&&")) {
    token.input(is);
    // cout << "logical_AND_expression, token=" << token.getStringValue() << endl;
    JBLParserResult rhs = inclusive_OR_expression(is);
    
    if (lhs.isBaseCut()) {
      BaseCut& lhsval (*lhs.getBaseCutValue());
      if (rhs.isBaseCut()) {
        BaseCut& rhsval (*rhs.getBaseCutValue());
        lhs = JBLParserResult (lhsval && rhsval); 
      }
//       else if (rhs.isBool()) {
//         bool rhsval = rhs.getBoolValue();
//         lhs = JBLParserResult (lhsval && rhsval); break;
//       }
    }
    else if (lhs.isBool()) {
      bool lhsval = lhs.getBoolValue();
//       if (rhs.isBaseCut()) {
//         BaseCut& rhsval (*rhs.getBaseCutValue());
//         lhs = JBLParserResult (lhsval && rhsval); break;
//       }
//       else 
      if (rhs.isBool()) {
        bool rhsval =rhs.getBoolValue();
        lhs = JBLParserResult (lhsval && rhsval);
      }
    }
    else {
      cerr << "JBLParserResult::logical_AND_expression: cannot AND '" << lhs.name << "' and '" 
           << rhs.name << "'!\n";
    }
  }
  // cout << "   logical_AND_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::inclusive_OR_expression (istream& is) {
  // cout << "inclusive_OR_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = exclusive_OR_expression(is);
  while (token.isOperator() && (token.getStringValue() == "|")) {
    token.input(is);
    JBLParserResult rhs = exclusive_OR_expression(is);
    
    if (lhs.isIntFun()) {
      IntFun& lhsval (*lhs.getIntFunValue());
      if (rhs.isIntFun()) {
        IntFun& rhsval (*rhs.getIntFunValue());
        lhs = JBLParserResult (lhsval | rhsval); 
      }
      else if (rhs.isInt()) {
        int rhsval = rhs.getIntValue();
        lhs = JBLParserResult (lhsval | rhsval); 
      }
    }
    else if (lhs.isInt()) {
      int lhsval = lhs.getIntValue();
      if (rhs.isIntFun()) {
        IntFun& rhsval (*rhs.getIntFunValue());
        lhs = JBLParserResult (lhsval | rhsval); 
      }
      else if (rhs.isInt()) {
        int rhsval =rhs.getIntValue();
        lhs = JBLParserResult (lhsval | rhsval); 
      }
    }
    else {
      cerr << "JBLParserResult::inclusive_OR_expression: cannot OR '" << lhs.name << "' and '" 
           << rhs.name << "'!\n";
    }
  }
  // cout << "   inclusive_OR_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::exclusive_OR_expression (istream& is) {
  // cout << "exclusive_OR_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = AND_expression(is);
  while (token.isOperator() && (token.getStringValue() == "^")) {
    token.input(is);
    JBLParserResult rhs = AND_expression(is);
    
    if (lhs.isIntFun()) {
      IntFun& lhsval (*lhs.getIntFunValue());
      if (rhs.isIntFun()) {
        IntFun& rhsval (*rhs.getIntFunValue());
        lhs = JBLParserResult (lhsval ^ rhsval); 
      }
      else if (rhs.isInt()) {
        int rhsval = rhs.getIntValue();
        lhs = JBLParserResult (lhsval ^ rhsval); 
      }
    }
    else if (lhs.isInt()) {
      int lhsval = lhs.getIntValue();
      if (rhs.isIntFun()) {
        IntFun& rhsval (*rhs.getIntFunValue());
        lhs = JBLParserResult (lhsval ^ rhsval); 
      }
      else if (rhs.isInt()) {
        int rhsval =rhs.getIntValue();
        lhs = JBLParserResult (lhsval ^ rhsval); 
      }
    }
    else {
      cerr << "JBLParserResult::exclusive_OR_expression: cannot OR '" << lhs.name << "' and '" 
           << rhs.name << "'!\n";
    }
  }
  // cout << "   exclusive_OR_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::AND_expression (istream& is) {
  // cout << "AND_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = equality_expression(is);
  while (token.isOperator() && (token.getStringValue() == "&")) {
    token.input(is);
    JBLParserResult rhs = equality_expression(is);
    
    if (lhs.isIntFun()) {
      IntFun& lhsval (*lhs.getIntFunValue());
      if (rhs.isIntFun()) {
        IntFun& rhsval (*rhs.getIntFunValue());
        lhs = JBLParserResult (lhsval & rhsval); 
      }
      else if (rhs.isInt()) {
        int rhsval = rhs.getIntValue();
        lhs = JBLParserResult (lhsval & rhsval); 
      }
    }
    else if (lhs.isInt()) {
      int lhsval = lhs.getIntValue();
      if (rhs.isIntFun()) {
        IntFun& rhsval (*rhs.getIntFunValue());
        lhs = JBLParserResult (lhsval & rhsval); 
      }
      else if (rhs.isInt()) {
        int rhsval =rhs.getIntValue();
        lhs = JBLParserResult (lhsval & rhsval); 
      }
    }
    else {
      cerr << "JBLParserResult::AND_expression: cannot AND '" << lhs.name << "' and '" 
           << rhs.name << "'!\n";
    }
  }
  // cout << "   AND_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::makeoperation (int op, const std::string& opname, JBLParserResult& lhs, JBLParserResult& rhs) { 
  if (lhs.isIntFun()) {
    if (rhs.isIntFun())           return comparison (op, *lhs.getIntFunValue(),   *rhs.getIntFunValue());
    else if (rhs.isInt())         return comparison (op, *lhs.getIntFunValue(),    rhs.getIntValue());
  }
  else if (lhs.isInt()) {
    if (rhs.isIntFun())           return comparison (op,  lhs.getIntValue(),      *rhs.getIntFunValue());
    else if (rhs.isInt())         return comparison (op,  lhs.getIntValue(),       rhs.getIntValue());
    else if (rhs.isFloatFun())    return comparison (op,  lhs.getFloatValue(),    *rhs.getFloatFunValue());
    else if (rhs.isFloat())       return comparison (op,  lhs.getFloatValue(),     rhs.getFloatValue());
  }
  else if (lhs.isFloatFun()) {
    if (rhs.isFloatFun())         return comparison (op, *lhs.getFloatFunValue(), *rhs.getFloatFunValue());
    else if (rhs.isNumber())      return comparison (op, *lhs.getFloatFunValue(),  rhs.getFloatValue());
  }
  else if (lhs.isFloat()) {
    if (rhs.isFloatFun())         return comparison (op,  lhs.getFloatValue(),    *rhs.getFloatFunValue());
    else if (rhs.isNumber())      return comparison (op,  lhs.getFloatValue(),     rhs.getFloatValue());
  }
  std::string error = "makeoperation: Cannot generate operator"+opname
                      + " between " + lhs.getName() + " and " + rhs.getName() +"!";
  return syntaxError (error);
}

JBLParserResult JBLParserResult::equality_expression (istream& is) {
  // cout << "equality_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = relational_expression(is);
  while (token.isOperator()) {
    int op = -1;
    string opname = token.getStringValue();
    if      (opname == "==") op=0;
    else if (opname == "!=") op=1;
    else return lhs;
    token.input(is);
    JBLParserResult rhs = relational_expression(is);
    
    lhs = makeoperation (op, opname, lhs, rhs);
  }
  // cout << "   equality_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::relational_expression (istream& is) {
  // cout << "relational_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs = shift_expression(is);
  while (token.isOperator()) {
    int op = -1;
    string opname = token.getStringValue();
    if      (opname == "<")  op=2;
    else if (opname == "<=") op=3;
    else if (opname == ">")  op=4;
    else if (opname == ">=") op=5;
    else return lhs;
    token.input(is);
    JBLParserResult rhs = shift_expression(is);
    
    lhs = makeoperation (op, opname, lhs, rhs);
  }
//     if (lhs.isIntFun()) {
//       if (rhs.isIntFun())           lhs = comparison (op, opname, *lhs.getIntFunValue(),   *rhs.getIntFunValue());
//       else if (rhs.isInt())         lhs = comparison (op, opname, *lhs.getIntFunValue(),    rhs.getIntValue());
//     }
//     else if (lhs.isInt()) {
//       if (rhs.isIntFun())           lhs = comparison (op,  lhs.getIntValue(),      *rhs.getIntFunValue());
//       else if (rhs.isInt())         lhs = comparison (op,  lhs.getIntValue(),       rhs.getIntValue());
//       else if (rhs.isFloatFun())    lhs = comparison (op,  lhs.getFloatValue(),    *rhs.getFloatFunValue());
//       else if (rhs.isFloat())       lhs = comparison (op,  lhs.getFloatValue(),     rhs.getFloatValue());
//     }
//     else if (lhs.isFloatFun()) {
//       if (rhs.isFloatFun())         lhs = comparison (op, *lhs.getFloatFunValue(), *rhs.getFloatFunValue());
//       else if (rhs.isNumber())      lhs = comparison (op, *lhs.getFloatFunValue(),  rhs.getFloatValue());
//     }
//     else if (lhs.isFloat()) {
//       if (rhs.isFloatFun())         lhs = comparison (op,  lhs.getFloatValue(),    *rhs.getFloatFunValue());
//       else if (rhs.isNumber())      lhs = comparison (op,  lhs.getFloatValue(),     rhs.getFloatValue());
//     }
//   }
  // cout << "   relational_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::shift_expression (istream& is) {
  return additive_expression(is);
}


JBLParserResult JBLParserResult::additive_expression (istream& is) {
  // cout << "additive_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs;
  if (token.isEmpty()) return lhs;
  lhs = multiplicative_expression (is);
    
  while (token.isOperator()) {
    int op = -1;
    string opname = token.getStringValue();
    if      (opname == "+")  op=6;
    else if (opname == "-")  op=7;
    else return lhs;
    token.input(is);
    JBLParserResult rhs = multiplicative_expression (is);
    
    lhs = makeoperation (op, opname, lhs, rhs);
  }
  // cout << "   primary_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::multiplicative_expression (istream& is) {
  // cout << "multiplicative_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs;
  if (token.isEmpty()) return lhs;
  lhs = cast_expression(is);
  
  while (token.isOperator()) {
    int op = -1;
    string opname = token.getStringValue();
    if (opname == "*")       op=8;
    else if (opname == "/")  op=9;
    else return lhs;
    token.input(is);
    JBLParserResult rhs = cast_expression (is);
 
    lhs = makeoperation (op, opname, lhs, rhs);
    
  }
  // cout << "   multiplicative_expression lhs: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::cast_expression (istream& is) {
  return unary_expression (is);
}

JBLParserResult JBLParserResult::unary_expression (istream& is) {
  // cout << "unary_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult result;
  if (token.isEmpty()) return result;
  int sign = 1;
  if (token.isOperator()) {
    if (token.getStringValue() == "+" || token.getStringValue() == "-") {
      if (token.getStringValue() == "+") {}
      else if (token.getStringValue() == "-") {sign = -1;}
      token.input(is);
      result = cast_expression(is);
      if (sign < 0) {
        switch (result.type) {
          case JBLParserResult::INT:    
            result = JBLParserResult(-result.getIntValue());   break;
          case JBLParserResult::FLOAT:  
            result = JBLParserResult(-result.getFloatValue()); break;
          case JBLParserResult::FLOATFUN: 
            result = JBLParserResult(-(*result.getFloatFunValue())); break;
          case JBLParserResult::INTFUN: 
            result = JBLParserResult(-(*result.getIntFunValue())); break;
          default: syntaxError ("unary_expression: Unary minus not permitted here!");
        }
      }
    }
    else if (token.getStringValue() == "!") {
      token.input(is);
      result = cast_expression(is);
      switch (result.type) {
        case JBLParserResult::BOOL:    
          result = JBLParserResult(!result.getBoolValue());  break;
        case JBLParserResult::BASECUT:  
          result = JBLParserResult(!(*result.getBaseCutValue())); break;
        default: syntaxError ("unary_expression: Operator ! not permitted here!");
      }
    }
    else if (token.getStringValue() == "~") {
      token.input(is);
      result = cast_expression(is);
      switch (result.type) {
        case JBLParserResult::INT:  
            result = JBLParserResult(~result.getIntValue());   break;
        case JBLParserResult::INTFUN:  
          result = JBLParserResult(~(*result.getIntFunValue())); break;
        default: syntaxError ("unary_expression: Operator ~ not permitted here!");
      }
    }
  }
  else result = postfix_expression(is);
  // cout << "   unary_expression result: " << result.name << ", type=" << result.type << '\n';
  return result;
}

JBLParserResult JBLParserResult::postfix_expression (istream& is) {
  // cout << "postfix_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult result;
  if (token.isEmpty()) return result;
  result = primary_expression (is);

  // cout << "postfix_expression: primary_expression='" << result.getName() 
  //      << "', token='" << token.getStringValue() << "'\n";
  if (token.isParanthesis() && token.getStringValue() == "(") {
    token.input(is);
    JBLParserResult argument;
    if (token.isParanthesis() && token.getStringValue() == ")") {
      // cout << "postfix_expression: empty argument list\n";
    }
    else {
      argument = argument_expression_list (is);
      // cout << "postfix_expression: argument list = '" << argument.name << "'\n";
      if (!token.isParanthesis() || !(token.getStringValue() == ")")) syntaxError ("postfix_expression: Wrong paranthesis! ) expected");
    }
    token.input(is);
    
    // cout << "postfix_expression: argument = " << argument.name << '\n';
    
    if (result.isIdentifier()) {
      return result = makefloatfunction(result.name,  argument);
    }
  }  
  
  // cout << "   postfix_expression result: " << result.name << ", type=" << result.type << '\n';
  return result;
}

JBLParserResult JBLParserResult::primary_expression (istream& is) {
  // cout << "primary_expression: starting, token=" << token.getStringValue() << endl;
  JBLParserResult result;
  if (token.isEmpty()) return result;
  if (token.isIdentifier()) {
    // cout << "primary_expression: Identifier '" << token.getStringValue() << "'\n";
    if (IntFun *i=IntFun::getObject (token.getStringValue())) result = JBLParserResult(*i);
    else if (FloatFun *f=FloatFun::getObject (token.getStringValue())) result = JBLParserResult(*f);
    else if (BaseCut *b=BaseCut::getObject (token.getStringValue())) result = JBLParserResult(*b);
    else result = JBLParserResult(token.getStringValue());
  }
  else if (token.isParanthesis()) {
    if (!(token.getStringValue() == "(")) result =  syntaxError ("primary_expression: Wrong paranthesis! ( expected");
    token.input(is);
    result = expression(is);
    if (!(token.getStringValue() == ")")) syntaxError ("primary_expression: Wrong paranthesis! ) expected");
  }
  else if (token.isNumber()) {
    // cout << "primary_expression: Number '" << token.getStringValue() << "'\n";
    if (token.isInt())  result = JBLParserResult(token.getIntValue());
    else                result = JBLParserResult(token.getFloatValue());
  }  
  else if (token.isBool()) {
    // cout << "primary_expression: Bool '" << token.getStringValue() << "'\n";
    result = JBLParserResult(token.getBoolValue());
  }  
  else result = syntaxError ("primary_expression: syntax error!");
  // cout << "   primary_expression result: " << result.name << ", type=" << result.type << '\n';
  token.input (is);
  return result;
}

JBLParserResult JBLParserResult::argument_expression_list (istream& is) {
  // cout << "argument_expression_list: starting, token=" << token.getStringValue() << endl;
  JBLParserResult lhs;
  if (token.isEmpty()) return lhs;
  lhs = assignment_expression (is);
  
  while (token.isOperator()) {
    if (!(token.getStringValue() == ",")) return lhs;
    token.input(is);
    JBLParserResult rhs = assignment_expression(is);
    
    lhs.addCopyToList(rhs);
    
  }
   
  // cout << "   argument_expression_list result: " << lhs.name << ", type=" << lhs.type << '\n';
  return lhs;
}

JBLParserResult JBLParserResult::syntaxError (const string& text) {
  std::cerr << text << ", next token: " << token.getStringValue() << std::endl;
  return JBLParserResult();
}
      
void JBLParserResult::initMaps() {
  theMap_f_f      = new Map_f_f      ;
  theMap_f_f_f    = new Map_f_f_f    ;
  theMap_f_f_i    = new Map_f_f_i    ;
  theMap_i_i      = new Map_i_i      ;
  theMap_FF_FF    = new Map_FF_FF    ;
  theMap_FF_FF_FF = new Map_FF_FF_FF ;
  theMap_FF_FF_IF = new Map_FF_FF_IF ;
  theMap_IF_IF    = new Map_IF_IF    ;
  
  (*theMap_f_f)["abs"]    = &std::abs;
  (*theMap_f_f)["acos"]   = &std::acos;
  (*theMap_f_f)["asin"]   = &std::asin;
  (*theMap_f_f)["atan"]   = &std::atan;
  (*theMap_f_f)["ceil"]   = &std::ceil;
  (*theMap_f_f)["cos"]    = &std::cos;
  (*theMap_f_f)["cosh"]   = &std::cosh;
  (*theMap_f_f)["exp"]    = &std::exp;
  (*theMap_f_f)["fabs"]   = &std::fabs;
  (*theMap_f_f)["floor"]  = &std::floor;
  (*theMap_f_f)["log"]    = &std::log;
  (*theMap_f_f)["log10"]  = &std::log10;
  (*theMap_f_f)["sin"]    = &std::sin;
  (*theMap_f_f)["sinh"]   = &std::sinh;
  (*theMap_f_f)["sqrt"]   = &std::sqrt;
  (*theMap_f_f)["tan"]    = &std::tan;
  (*theMap_f_f)["tanh"]   = &std::tanh;
  (*theMap_f_f)["square"] = &square;
  (*theMap_f_f)["rad"]    = &rad;
  (*theMap_f_f)["deg"]    = &deg;
  
  (*theMap_FF_FF)["abs"]    = &abs;
  (*theMap_FF_FF)["acos"]   = &acos;
  (*theMap_FF_FF)["asin"]   = &asin;
  (*theMap_FF_FF)["atan"]   = &atan;
  (*theMap_FF_FF)["ceil"]   = &ceil;
  (*theMap_FF_FF)["cos"]    = &cos;
  (*theMap_FF_FF)["cosh"]   = &cosh;
  (*theMap_FF_FF)["exp"]    = &exp;
  (*theMap_FF_FF)["fabs"]   = &fabs;
  (*theMap_FF_FF)["floor"]  = &floor;
  (*theMap_FF_FF)["log"]    = &log;
  (*theMap_FF_FF)["log10"]  = &log10;
  (*theMap_FF_FF)["sin"]    = &sin;
  (*theMap_FF_FF)["sinh"]   = &sinh;
  (*theMap_FF_FF)["sqrt"]   = &sqrt;
  (*theMap_FF_FF)["tan"]    = &tan;
  (*theMap_FF_FF)["tanh"]   = &tanh;
  (*theMap_FF_FF)["square"] = &square;
  (*theMap_FF_FF)["rad"]    = &rad;
  (*theMap_FF_FF)["deg"]    = &deg;

  (*theMap_i_i)["abs"]    = &std::abs;
  (*theMap_i_i)["square"] = &square;

  (*theMap_IF_IF)["abs"]    = &abs;
  (*theMap_IF_IF)["square"] = &square;
  
  (*theMap_f_f_i)["pow"]    = &std::pow;
  
  (*theMap_f_f_f)["atan2"]  = &std::atan2;
  (*theMap_f_f_f)["pow"]    = &std::pow;
  
  (*theMap_FF_FF_FF)["atan2"] = &atan2;
  (*theMap_FF_FF_FF)["atan2"] = &pow;
  
  std::cout << "JBLParserResult: maps initialized!" << std::endl;
}

std::ostream& JBLParserResult::print(std::ostream& os) const {
  if      (isEmpty())       os << "EMPTY";
  else if (isInt())         os << "INT "          << getIntValue();
  else if (isFloat())       os << "FLOAT "        << getFloatValue();
  else if (isBool())        os << "BOOL "         << (getBoolValue() ? "true" : "false");
  else if (isIntFun())      os << "INTFUN "       << getIntFunValue()->getName();
  else if (isFloatFun())    os << "FLOATFUN "     << getFloatFunValue()->getName();
  else if (isBaseCut())     os << "BASECUT "      << getBaseCutValue()->getName();
  else if (isIdentifier())  os << "IDENTIFIER '"  << getName() << "'";
  if (next) {
    os << ", ";
    next->print (os);
  }
  return os;
}
  

istream& operator>> (istream& is, JBLParserResult& result) {
  result = JBLParserResult::parseExpression (is);
  return is;
}

ostream& operator<< (ostream& os, const JBLParserResult& result) {
  return result.print (os);
}

int JBLParserResult::Init::counter = 0;

JBLParserResult::Init::Init() {
  if (counter++ == 0) JBLParserResult::initMaps();
}

---