In This Package:

CreateRules.cc

Go to the documentation of this file.

//
// RuleParser
// Code that uses the Boost SPIRIT parser to deconstruct
// a string into a selection that can be run quickly.
//  
#include <boost/spirit/core.hpp>
#include <boost/spirit/symbols/symbols.hpp>
#include <boost/spirit/utility.hpp>
#include <boost/spirit/dynamic.hpp>

#include <iostream>
#include <string>
#include <stack>
#include <typeinfo>
#include <algorithm>
#include <cctype>

#include "RuleParser/ParameterDescription.h"
#include "RuleParser/Rules.h"
#include "RuleParser/RuleFactory.h"
#include "RuleParser/CreateRules.h"
#include "units.h"

using namespace std;
using namespace boost::spirit;
using namespace RuleParser;




// Storage for semantic actions.
struct ParserStore
{
  // Temporary data storage
  stack<std::string>          mStackOperators;
  stack<double>               mStackDouble;
  stack<double>               mStackUnit;
  stack<string>               mStackString;
  stack<ParameterDescription> mStackParam; 
  stack<Rule*>                mStackRules;    

  stack<string>               mTempStack;

  void popval(double& r) { r = mStackDouble.top(); mStackDouble.pop();};
  void popval(string& r) { r = mStackString.top(); mStackString.pop();};

  void clear() { 
    while(! mStackOperators.empty()) mStackOperators.pop();
    while(! mStackDouble   .empty()) mStackDouble   .pop();
    while(! mStackString   .empty()) mStackString   .pop();
    while(! mStackParam    .empty()) mStackParam    .pop();
    while(! mStackRules    .empty()) mStackRules    .pop();
  };
};


//
//  Semantic actions
//

struct debugprint{
  debugprint(std::string n) : name(n) {};
  std::string name;
  void operator()(char const* a, char const* b) const{
    string s(a,b);
    //cout << "      debugprint name=" << name << " matched " << s << std::endl;
  }
  void operator()(char const* a) const{
    //cout << "      debugprint name=" << name << " matched char " << a << std::endl;
  }
  void operator()(const double &a) const{
    //cout << "      debugprint name=" << name << " matched double " << a << std::endl;
  }
};

struct mySemantic {
  mySemantic(ParserStore& rp) : m_store(rp) {};
  ParserStore& m_store;
};

struct my_do_double : public mySemantic
{
  my_do_double(ParserStore& rp) : mySemantic(rp) {};
  void operator()(const double &d) const{
    m_store.mStackDouble.push(d);
  }
};

struct my_do_string : public mySemantic
{
  my_do_string(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* a, char const* b) const{
    string s(a,b);
    m_store.mStackString.push(s);
  }
};

struct my_do_unit : public mySemantic
{
  my_do_unit(ParserStore& rp) : mySemantic(rp) {};
  void operator()(const double &d) const{
    m_store.mStackUnit.push(d);
  }
};

struct my_do_double_with_unit : public mySemantic
{
  my_do_double_with_unit(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const*, char const*) const {
    assert(m_store.mStackUnit.size()>0);
    assert(m_store.mStackDouble.size()>0);
    double d = m_store.mStackUnit.top() * m_store.mStackDouble.top();
    m_store.mStackDouble.pop();
    m_store.mStackUnit.pop();
    m_store.mStackDouble.push(d);
  }
};

struct my_do_param : public mySemantic
{
  my_do_param(ParserStore& rp) : mySemantic(rp) {};
    // void operator()(char const* a, char const* b) const{
    //   string s(a,b);
    //   m_store.mStackParamName.push(s);
    //   cout << "Stacking " << s << std::endl;
    // }
  void operator()(const ParameterDescription& d) const {
    //cout << "Stacking parameter " << d.name() << " " << d.id() << " " << d.type() << std::endl;
    m_store.mStackParam.push(d);
  }
};

struct my_do_operator : public mySemantic
{
  my_do_operator(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* a, char const* b) const{
    std::string s(a,b);
    //cout << "Stacking operator " << s << std::endl;
    m_store.mStackOperators.push(s);
  }      
    // void operator()(char const a) const{
    //   std::string s(1,a);
    //   cout << "Stacking operator " << s << std::endl;
    //   m_store.mStackOperators.push(s);
    // }      
};


template<typename T>
struct my_do_simple_comparison : public mySemantic
{
  my_do_simple_comparison(ParserStore& rp,bool param_on_left) : mySemantic(rp), m_param_on_left(param_on_left){};
  bool m_param_on_left;

  void operator()(char const* a, char const* b) const{
    
    //cout<<"cmp string a: "<<a<<endl;
    //cout<<"cmp string b: "<<b<<endl;
    
    string s(a,b);
    T val;
    m_store.popval(val);

    ParameterDescription par = m_store.mStackParam.top();
    m_store.mStackParam.pop();

    string op = m_store.mStackOperators.top();
    m_store.mStackOperators.pop();

      // check handedness.. flip if not 'standard handedness'
    if(m_param_on_left != true) {
      if(op == "<" ) op = ">";
      if(op == "<=") op = ">=";
      if(op == ">" ) op = "<";
      if(op == ">=") op = "<=";
    }

    Rule* outRule = 0;
    if(op=="<" ) outRule = new LT_Rule<T>(s,par.id(),val);
    if(op=="<=") outRule = new LE_Rule<T>(s,par.id(),val);
    if(op==">" ) outRule = new GT_Rule<T>(s,par.id(),val);
    if(op==">=") outRule = new GE_Rule<T>(s,par.id(),val);
    if(op=="==" || op=="=") outRule = new EQ_Rule<T>(s,par.id(),val);
    if(op=="!=") outRule = new NEQ_Rule<T>(s,par.id(),val);

    assert(outRule);
    m_store.mStackRules.push(outRule);
    //cout << "STACK rule " << typeid(*outRule).name() << "  \"" << outRule->name() << "\"" << endl;
  }
};


template <typename T>
struct my_do_custom : public mySemantic
{
  my_do_custom(ParserStore& rp,
               const ParameterDescription& par,
               int which_operator,
               bool param_on_left) 
          : mySemantic(rp)
          , m_par(par)
          , m_which_operator(which_operator)
          , m_param_on_left(param_on_left){};

  const ParameterDescription& m_par;
  int  m_which_operator;
  bool m_param_on_left;

  void operator()(char const* , char const* ) const{
      // This is a custom rule provided by the user. Call on his/her RuleFactor to make it.
    T val;
    m_store.popval(val);

    assert(m_par.factory());
    Rule* rule = m_par.factory()->createRule(m_par, m_which_operator, val, m_param_on_left);

    assert(rule);
    m_store.mStackRules.push(rule);
    //cout << "STACK custom rule " << typeid(*rule).name() << "  \"" << rule->name() << "\"" << endl;         
  }
};

struct my_do_and : public mySemantic
{
  my_do_and(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* a, char const* b) const{

    //cout<<"string a: "<<a<<endl;
    //cout<<"string b: "<<b<<endl;

    string s(a,b);

    assert(m_store.mStackRules.size()>=2);
    Rule* rule2 = m_store.mStackRules.top();
    m_store.mStackRules.pop();

    Rule* rule1 = m_store.mStackRules.top();
    m_store.mStackRules.pop();

    string name=rule1->name();
    name.append(" ");
    name.append(s);

    Rule* outRule = new AndRule(name,rule1,rule2);
    //cout << "STACK and-rule composed of " << rule1->name() << " and " << rule2->name() << std::endl;

    m_store.mStackRules.push(outRule);
  }    
};

struct my_do_or : public mySemantic
{
  my_do_or(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* a, char const* b) const{

    //cout<<"string a: "<<a<<endl;
    //cout<<"string b: "<<b<<endl;

    string s(a,b);

    assert(m_store.mStackRules.size()>=2);
    Rule*  rule2 = m_store.mStackRules.top();
    m_store.mStackRules.pop();

    Rule*  rule1 = m_store.mStackRules.top();
    m_store.mStackRules.pop();

    string name=rule1->name();
    name.append(" ");
    name.append(s);

    Rule* outRule = new OrRule(name,rule1,rule2);
    //cout << "STACK or-rule composed of " << rule1->name() << " and " << rule2->name() << std::endl;

    m_store.mStackRules.push(outRule);
  }    
};

struct my_do_not : public mySemantic
{
  my_do_not(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* a, char const* b) const{
    assert(m_store.mStackRules.size()>=1);
    Rule* rule1 = m_store.mStackRules.top();
    m_store.mStackRules.pop();

    Rule* outRule = new NotRule(string(a,b),rule1);
    //cout << "STACK not-rule composed of " << rule1->name() << std::endl;

    m_store.mStackRules.push(outRule);
  }    
};

struct my_do_any : public mySemantic
{
  my_do_any(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* , char const* ) const{
    //cout << "STACK any-rule " << std::endl;

    m_store.mStackRules.push(new AnyRule);
  }    
};

struct my_do_none : public mySemantic
{
  my_do_none(ParserStore& rp) : mySemantic(rp) {};
  void operator()(char const* , char const* ) const{
    // cout << "STACK none-rule " << std::endl;

    m_store.mStackRules.push(new NoneRule);
  }    
};



//
//  Description of our grammar
//

struct ruleparser : public grammar<ruleparser>
{  
  ruleparser(ParserStore& s, ParameterList pars) 
    : m_store(s)
    , m_pars(pars) {};
  ParserStore &m_store;
  ParameterList m_pars;

  template <typename ScannerT>
  struct definition
  {
    definition(const ruleparser& self)
    {   
      // Load units.
      static unitlist sUnitlist;
      const unitlist::UnitList_t& ulist = sUnitlist();
      unitlist::UnitList_t::const_iterator it = ulist.begin();
      for( ; it != ulist.end(); ++it ){
        unit_symbols.add(it->first.begin(),it->first.end(),it->second);
      }
      
      
      value_real
        = (real_p[my_do_double(self.m_store)] >> unit_symbols[my_do_unit(self.m_store)][debugprint("unit")])
          [my_do_double_with_unit(self.m_store)][debugprint("realvalue-with-unit")]
        | (real_p[my_do_double(self.m_store)])[debugprint("realvalue")]
        ;

          // Strings must be single-quoted, contain only a-z,A-Z,0-9,/,_
      value_string
        = ch_p('\'') >> (*(alnum_p | ch_p('/') | ch_p('-')| ch_p('_')))[my_do_string(self.m_store)][debugprint("stringvalue")] >> ch_p('\'')
        ;

      custom_comparison = nothing_p;

      for(unsigned int i=0; i<self.m_pars.size(); i++) {
        const ParameterDescription& par = self.m_pars[i];
        // change to a lowercase name so it will match with a as_lower_d directive
        // use the temporary stack to store an actual string location, so it is still there
        // when the parser runs.
        std::string temp = par.name();
        for(std::string::iterator c = temp.begin(); c!= temp.end(); ++c)  *c = tolower(*c);
        self.m_store.mTempStack.push(temp);
        std::string& parname = self.m_store.mTempStack.top();
        //cout << "Setting rules for parameter " << par.name() << "\t" << parname << endl;
        
        if( par.factory() ) {
        // It's a custom type. Set up custom rules for it.
        // Add one line for every operator allowed.
        for(unsigned int iop=0; iop < par.operators().size(); ++iop){
            std::string temp = par.operators()[iop];
            // change to a lowercase name so it will match with a as_lower_d directive
            for(std::string::iterator c = temp.begin(); c!= temp.end(); ++c)  *c = tolower(*c);
            self.m_store.mTempStack.push(temp);
            std::string& op = self.m_store.mTempStack.top();

            // Custom floating point parameter.
            if(par.type() == typeid(double).name()){
              custom_comparison 
                = (  as_lower_d[parname.c_str()]
                  >> as_lower_d[op.c_str()]
                  >> value_real
                  ) [my_do_custom<double>(self.m_store,par,iop,true)] // Lefthand operation
              
                | (  value_real
                  >> as_lower_d[op.c_str()]
                  >> as_lower_d[parname.c_str()] 
                  ) [my_do_custom<double>(self.m_store,par,iop,false)] // righthand operation
              
                | custom_comparison.copy() // Append.
                ;
            }
            
            // Custom string-or-who-knows
            else {
              custom_comparison 
                = (  as_lower_d[parname.c_str()]
                  >> as_lower_d[op.c_str()]
                  >> value_string
                  ) [my_do_custom<string>(self.m_store,par,iop,true)] // Lefthand operation
              
                | (  value_string
                  >> as_lower_d[op.c_str()]
                  >> as_lower_d[parname.c_str()] 
                  ) [my_do_custom<string>(self.m_store,par,iop,false)] // righthand operation
              
                | custom_comparison.copy() // Append.
                ;
            }
            
            
          }

        } else {
          // Not a custom type.
          
          if(par.type() == typeid(double).name())
            parlist_real.add(parname.begin(), parname.end(), par);
          else// If you dont' understand the type, treat it as a string.
            parlist_string.add(parname.begin(), parname.end(), par);
        }
      };

      // Match a name of parameter, after converting to lowercase.
      par_real   = as_lower_d[parlist_real[my_do_param(self.m_store)]];
      par_string = as_lower_d[parlist_string[my_do_param(self.m_store)]];

      // Valid numerical operators (int and double types)
      // N.B. Longer strings should go first, to ensure lazy matching doesn't screw you.
      operators_num 
        = str_p("<=" )
        | str_p(">=")
        | str_p("<" )
        | str_p(">")
        | str_p("==")
        | str_p("=" )
        | str_p("!=")
        ;
      
      // Valid string operators
      operators_string
        = str_p("==" )
        | str_p("=")
        | str_p("!=")
        ;

      basic_lefthand_comparison // e.g. pdgcode<2
        = (par_real   >> operators_num   [my_do_operator(self.m_store)] >> value_real  )[my_do_simple_comparison<double>(self.m_store,true)]
        | (par_string >> operators_string[my_do_operator(self.m_store)] >> value_string)[my_do_simple_comparison<string>(self.m_store,true)]
        ;

      basic_righthand_comparison // e.g. 2>pdgcode
        = (
          (value_real   >> operators_num   [my_do_operator(self.m_store)] >> par_real  )[my_do_simple_comparison<double>(self.m_store,false)]
        | (value_string >> operators_string[my_do_operator(self.m_store)] >> par_string)[my_do_simple_comparison<string>(self.m_store,false)]
        );

      // A comparison is a basic lhs comparison, a basic rhs comparison, or a custom comparison.
      comparison 
        = basic_lefthand_comparison[debugprint("lefthand-comparison")]
        | basic_righthand_comparison[debugprint("righthand-comparison")]
        | custom_comparison[debugprint("custom-comparison")]
        ;
        
      // An expression is a term, optionally followed by AND term, or OR term
      expression 
        = (term >>
             !( ((as_lower_d["and"]|str_p("&&")) >> term)[my_do_and(self.m_store)][debugprint("do-and")] 
              | ((as_lower_d["or"] |str_p("||")) >> term)[my_do_or(self.m_store)][debugprint("do-or")]
              )
           )[debugprint("expression")]
        ;

      // A term is 'any', 'none', comparison, (expression), or not term
      term
        =  (as_lower_d["any"] | as_lower_d["all"] )[my_do_any(self.m_store)]
        |  ( as_lower_d["none"]| as_lower_d["nothing"])[my_do_none(self.m_store)]
        |  comparison[debugprint("comparison-as-term")]
        |  ('(' >> expression >> ')')[debugprint("expression-as-term")]
        |  ((as_lower_d["not"]|str_p("!")) >> term)[my_do_not(self.m_store)][debugprint("do-not")][debugprint("not-as-term")]
        ;


      // Final result can be padded with whitespace.
      my_grammar
        = expression >> end_p
        ;
    }

    symbols<ParameterDescription> parlist_real;
    symbols<ParameterDescription> parlist_int;
    symbols<ParameterDescription> parlist_string;
    symbols<double> unit_symbols;
    stored_rule<ScannerT> custom_comparison;
    rule<ScannerT> operators_num;
    rule<ScannerT> operators_string;
    rule<ScannerT> par_real, par_int, par_string;
    rule<ScannerT> value_real, value_int, value_string;
    rule<ScannerT> basic_lefthand_comparison, basic_righthand_comparison;
    rule<ScannerT> comparison, term, selection, expression;    
    rule<ScannerT> my_grammar;
    const rule<ScannerT>&
      start() const { return my_grammar; }
  };
};




//
//  Main function
//

bool  RuleParser::CreateRules(
                             const std::string&    inString,
                             const ParameterList&  inParameters,
                             Rule*                 &outRule                   
                             )
{
  
  ParserStore store;  //mustn't delete until ruleparser is dead.
  ruleparser rp(store,inParameters);    //  Our parser

  // Default.
  outRule = 0; // Failure.

  if(inString.empty()) {
    // In the case of no selection, default to selecting nothing.
    outRule = new NoneRule;
  }
  
  store.clear();
  
  // Fix for a bug in Spirit.. this is the recommended workaround.
  parse_info<> info = parse(inString.c_str(), rp, space_p);

  if (info.full)
  {
    outRule = store.mStackRules.top();
    return true;
  }
  cerr << "-------------------------\n";
  cerr << "Parsing failed\n";
  cerr << "stopped at: \"" << info.stop << "\"\n";
  cerr << "-------------------------\n";
  return false;
}

---