JBLParserResult.h

Go to the documentation of this file.

#ifndef __JBLPARSERRESULT_H
#define __JBLPARSERRESULT_H

#include "jbltools/sfh/JBLToken.h"
#include "jbltools/sfh/Float_FF.h"
#include <string>
#include <iosfwd>

class FloatFun;
class IntFun;
class BaseCut;

//  Class JBLParserResult:

class JBLParserResult {
  public:
    // Constructors
    JBLParserResult();
    JBLParserResult(const JBLParserResult &rhs);
  private:
    JBLParserResult(int       intvalue_          
                   );
    JBLParserResult(Float_FF     floatvalue_          
                   );
    JBLParserResult(bool      boolvalue_          
                   );
    JBLParserResult(IntFun   &intfunvalue_          
                   );
    JBLParserResult(FloatFun &floatfunvalue_          
                   );
    JBLParserResult(BaseCut  &basecutvalue_          
                   );
    JBLParserResult(const std::string& name_          
                   );
  public:
    ~JBLParserResult();
    
    JBLParserResult& operator= (const JBLParserResult &rhs);
    
    bool isEmpty()  const      {return type == EMPTY;}
    bool isNumber() const      {return type & NUMBER;}
    bool isInt()  const        {return type == INT;}
    bool isFloat()  const      {return type == FLOAT;}
    bool isBool()  const       {return type == BOOL;}
    bool isIntFun() const      {return type == INTFUN;}
    bool isFloatFun() const    {return type == FLOATFUN;}
    bool isFun() const         {return type & FUN;}
    bool isBaseCut() const     {return type== BASECUT;}
    bool isIdentifier() const  {return type== IDENTIFIER;}
    int  listlength() const;
    
    const std::string& getName() const     {return name;}
    
    static JBLParserResult parseExpression (const std::string& input);
    
    static JBLParserResult parseExpression (std::istream& is);
    
    int    getIntValue() const;
    Float_FF  getFloatValue() const;
    bool   getBoolValue() const;
    
    IntFun   *getIntFunValue() const;
    FloatFun *getFloatFunValue() const;
    BaseCut  *getBaseCutValue() const;
    
    std::ostream& print(std::ostream& os  
                       ) const;
    JBLParserResult& addCopyToList(const JBLParserResult &rhs   
                                  );
  private:
    static JBLToken token;
    
    static JBLParserResult expression (std::istream& is);
    static JBLParserResult assignment_expression (std::istream& is);
    static JBLParserResult conditional_expression (std::istream& is);
    static JBLParserResult logical_OR_expression (std::istream& is);
    static JBLParserResult logical_AND_expression (std::istream& is);
    static JBLParserResult inclusive_OR_expression (std::istream& is);
    static JBLParserResult exclusive_OR_expression (std::istream& is);
    static JBLParserResult AND_expression (std::istream& is);
    static JBLParserResult equality_expression (std::istream& is);
    static JBLParserResult relational_expression (std::istream& is);
    static JBLParserResult shift_expression (std::istream& is);
    static JBLParserResult additive_expression (std::istream& is);
    static JBLParserResult multiplicative_expression (std::istream& is);
    static JBLParserResult cast_expression (std::istream& is);
    static JBLParserResult unary_expression (std::istream& is);
    static JBLParserResult postfix_expression (std::istream& is);
    static JBLParserResult primary_expression (std::istream& is);
    static JBLParserResult argument_expression_list (std::istream& is);
    static JBLParserResult syntaxError (const std::string& text);

    template <class T1, class T2>  
    static JBLParserResult comparison (int op, const T1& lhs, const T2& rhs);

    static JBLParserResult makeoperation (int op, const std::string& opname, JBLParserResult& lhs, JBLParserResult& rhs);
    
    static JBLParserResult makefloatfunction (const std::string& fname, JBLParserResult& arglist);

  private:
    enum Type {EMPTY=0, INT=1, FLOAT=2, NUMBER=3, BOOL=4, INTFUN=8, FLOATFUN=16, FUN=24, BASECUT=32, IDENTIFIER=64};

  public:
    typedef Float_FF  (*Fun_f_f)     (Float_FF);   // pointer to function returning a Float_FF, with a Float_FF argument
    typedef Float_FF  (*Fun_f_f_f)   (Float_FF,Float_FF);   // function returning a Float_FF, with 2 float arguments
    typedef Float_FF  (*Fun_f_f_i)   (Float_FF,Float_FF);   // function returning a float, with a float and an int argument
    typedef int       (*Fun_i_i)     (int);     // function returning an int, with an int argument
    typedef bool      (*Fun_b_b)     (bool);    // function returning a bool, with a bool argument
    typedef FloatFun& (*Fun_FF_FF)   (const FloatFun&);   // function returning a floFloatFun, with a FloatFun argument
    typedef FloatFun& (*Fun_FF_FF_FF)(const FloatFun&,const FloatFun&);   // function returning a FloatFun, with 2 FloatFun arguments
    typedef FloatFun& (*Fun_FF_FF_IF)(const FloatFun&,const IntFun&);   // function returning a FloatFun, with a FloatFun and an IntFun argument
    typedef IntFun&   (*Fun_IF_IF)   (const IntFun&);   // function returning a floIntFun, with a IntFun argument
    typedef BaseCut&  (*Fun_BC_BC)   (const BaseCut&);   // function returning a floBaseCut, with a BaseCut argument
    
    
  private:
    // Data members
    Type             type;
    int              intvalue;
    Float_FF         floatvalue;
    bool             boolvalue;
    IntFun          *intfunvalue;
    FloatFun        *floatfunvalue;
    BaseCut         *basecutvalue;
    std::string      name;
    JBLParserResult *next;
    
  public:    
    static void initMaps();
    
  
  struct Init {
    Init();
    static int counter;
  };  
    
};

static JBLParserResult::Init the_Init_Object;


std::istream& operator>> (std::istream& is, JBLParserResult& result);


std::ostream& operator<< (std::ostream& os, const JBLParserResult& result);

#endif /* #ifndef __JBLPARSERRESULT_H */

---