Merge branch 'master' of https://gitlab.irap.omp.eu/CDPP/AMDA_Kernel

Benjamin Renard
2 parents de7354f6 a0761bde
Showing 4 changed files with 105 additions and 6 deletions Show diff stats
src/expressionParser/ExpressionContainer.hh
src/expressionParser/ExpressionParser.cc
src/expressionParser/ExpressionPrinter.hh
src/expressionParser/ParserGrammar.hh
+#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#define BOOST_MPL_LIMIT_LIST_SIZE 30
+#include <boost/mpl/list.hpp>
+
 #ifndef EXPRESSIONCONTAINER_HH_
 #define EXPRESSIONCONTAINER_HH_
  
@@ -22,6 +26,9 @@ struct op_powerTen{};
 struct op_plusSign {};
 struct op_minusSign {};
 struct op_const {};
+struct fun_three{};
+struct fun_two{};
+struct fun_one{};
  
 namespace Expression{
  
@@ -30,6 +37,8 @@ template &lt;typename tag&gt; struct binop;
 template <typename tag> struct unop;
 template <typename tag> struct comop;
 template <typename tag> struct funcop;
+template <typename tag> struct triop;
+template <typename tag> struct forop;
  
 typedef boost::variant<var,
 	boost::recursive_wrapper<unop <op_not> >,
@@ -49,7 +58,10 @@ typedef boost::variant&lt;var,
 	boost::recursive_wrapper<binop<op_powerTen> >,
 	boost::recursive_wrapper<unop<op_minusSign> >,
 	boost::recursive_wrapper<unop<op_plusSign> >,
-	boost::recursive_wrapper<unop<op_const> >
+	boost::recursive_wrapper<unop<op_const> >,
+        boost::recursive_wrapper<binop<fun_one> >,
+        boost::recursive_wrapper<triop<fun_two> >,
+        boost::recursive_wrapper<forop<fun_three> >
 > ExpressionContainer;
  
  
@@ -76,6 +88,25 @@ template &lt;typename tag&gt; struct unop
     explicit unop(const ExpressionContainer& o) : oper1(o) { }
     ExpressionContainer oper1;
 };
+template <typename tag> struct triop
+{
+    explicit triop(const ExpressionContainer& functionId,
+            const ExpressionContainer& l
+        , const ExpressionContainer& r)
+        : oper1(functionId), oper2(l), oper3(r) { }
+ExpressionContainer oper1, oper2, oper3;
+};
+
+template <typename tag> struct forop
+{
+    explicit forop(const ExpressionContainer& functionId,
+            const ExpressionContainer& l,
+            const ExpressionContainer& m,
+          const ExpressionContainer& r)
+        : oper1(functionId), oper2(l), oper3(m),oper4(r) { }
+ExpressionContainer oper1, oper2, oper3,oper4;
+};
+
  
 } /* namespace Expression */
  
@@ -5,6 +5,11 @@
  *      Author: akka
  */
  
+#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#define BOOST_MPL_LIMIT_LIST_SIZE 30
+#include <boost/mpl/list.hpp>
+
+
 #include <sstream>
  
 #include "ParserLogger.hh"
@@ -44,6 +44,11 @@ public:
     // Constants
     void operator()(const unop<op_const>& u) const{printUnique("",u.oper1);}
  
+    // Functions
+    void operator()(const forop<fun_three>& b) const { printFunctionThree(b.oper1, b.oper2, b.oper3,  b.oper4); }
+    void operator()(const triop<fun_two>& b) const { printFunctionTwo(b.oper1, b.oper2, b.oper3); }
+    void operator()(const binop<fun_one>& b) const { printFunctionOne(b.oper1, b.oper2); }
+    
     // printer
     void print(const std::string& op, const ExpressionContainer& l, const ExpressionContainer& r) const
     {
@@ -75,6 +80,37 @@ public:
             boost::apply_visitor(*this, r);
         _os << ")";
     }
+
+          void printFunctionThree(const ExpressionContainer& functionId, const ExpressionContainer& l, const ExpressionContainer& m, const ExpressionContainer& r) const
+    {
+        boost::apply_visitor(*this, functionId);
+        _os << "(";
+            boost::apply_visitor(*this, l);
+            _os << ',';
+            boost::apply_visitor(*this, m);
+            _os << ',';
+            boost::apply_visitor(*this, r);
+        _os << ")";
+    }
+          
+          void printFunctionTwo(const ExpressionContainer& functionId, const ExpressionContainer& l, const ExpressionContainer& r) const
+    {
+        boost::apply_visitor(*this, functionId);
+        _os << "(";
+            boost::apply_visitor(*this, l);
+            _os << ',';
+            boost::apply_visitor(*this, r);
+        _os << ")";
+    }
+    
+          void printFunctionOne(const ExpressionContainer& functionId, const ExpressionContainer& l) const
+    {
+        boost::apply_visitor(*this, functionId);
+        _os << "(";
+            boost::apply_visitor(*this, l);
+        _os << ")";
+    }
+
 };
  
 std::ostream& operator<<(std::ostream& os, const ExpressionContainer& e)
+#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#define BOOST_MPL_LIMIT_LIST_SIZE 30
+#include <boost/mpl/list.hpp>
+
 #ifndef PARSERGRAMMAR_HH_
 #define PARSERGRAMMAR_HH_
  
@@ -8,6 +12,7 @@
 #include "CustomFoldDirective.hh"
 #include "ParserToolbox.hh"
 #include "Properties.hh"
+#include "FunctionInfo.hh"
  
 namespace AMDA {
 namespace parser {
@@ -46,8 +51,11 @@ public:
 	pow_ = fold<funcop<op_power> >(greater_.alias())[powOperator_ >> greater_];
  
         greater_=  fold<comop<op_greater> >(lower_.alias())[greaterOperator_ >> lower_];
-        lower_ = fold<comop<op_lower> >( not_.alias())[lowerOperator_ >> not_];
+        lower_ = fold<comop<op_lower> >( functions_.alias())[lowerOperator_ >> functions_];
  
+        functions_ = (threeArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<Expression::forop <fun_three>>(_1,_2,_3,_4)] ||
+        (twoArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<Expression::triop <fun_two>>(_1,_2,_3)]||
+        (oneArgsFunction>>"(">>funArgs_>>")")[_val= boost::phoenix::construct<Expression::binop <fun_one>>(_1,_2)]|not_[_val=_1];
 	// UNARY OPERATIONS
 	not_ = (notOperator_ > const_) [_val = boost::phoenix::construct<Expression::unop <op_not>>(_1)] | const_[_val = _1];
  
@@ -55,7 +63,7 @@ public:
  	param_= (definedParams >>('(' >> (spectArgs_|vectorArgs_)>>')'))[_val='$'+_1+"["+qi::_2+"]"] ||
                 definedParams[_val='$'+_1]| simple[_val = _1];
  
-        
+        funArgs_=((expr_   |var_) |functions_); 
         simple = (('(' > expr_ > ')') | var_);
 	var_ = (+qi::char_('0','9') >> -qi::char_('.') >> -(+qi::char_('0','9'))) | ((qi::char_('.') >> +qi::char_('0','9')));
 	vectorArgs_%=qi::raw[qi::int_ > -(qi::char_(',')>>qi::int_) ];
@@ -74,6 +82,7 @@ public:
         greaterOrEqualOperator_   = qi::string(">=");
         lowerOrEqualOperator_   = qi::string("<=");
         lowerOperator_   = qi::char_("<");
+        componentOperator_   = qi::char_(",");
  
 	// Define available constants
 	std::map<std::string, std::string> existingConstants = ParserToolbox::getConstants(lProperties);
@@ -86,10 +95,23 @@ public:
 	for(std::vector<std::string>::iterator it = existingParams.begin(); it != existingParams.end(); ++it) {
 		definedParams.add(*it,*it);
 	}
+       
+        // Defined functions available 
+        std::map<std::string,FunctionInfo> existingFunctions = ParserToolbox::getFunctions(lProperties);
+        for(auto const& x : existingFunctions ) {
+                if (x.second.getNbArgs()==1) {
+                      oneArgsFunction.add(x.second.getIHMName(), x.second.getKernelName());
+                }else if (x.second.getNbArgs()==2) {
+                      twoArgsFunction.add(x.second.getIHMName(), x.second.getKernelName());
+                }else {
+                      threeArgsFunction.add(x.second.getIHMName(), x.second.getKernelName());
+                }
+        } 
+
  
         BOOST_SPIRIT_DEBUG_NODES((expr_)(or_)(and_)(equal_)(unequal_)(greaterOrEqual_)(lowerOrEqual_)(lower_)(sum_)
                 (difference_)(factor_)(division_)(simple)(notOperator_)(andOperator_)(orOperator_)(equalOperator_)(unequalOperator_)
-                (sumOperator_)(differenceOperator_)(factorOperator_)(divisionOperator_)(greater_)(lower_));
+                (sumOperator_)(differenceOperator_)(factorOperator_)(divisionOperator_)(greater_)(lower_)(functions_));
     }
  
 private:
@@ -113,7 +135,9 @@ private:
         ,lowerOrEqual_
         ,lower_
 	,const_
-	,param_;
+	,param_
+        ,functions_
+        ,funArgs_;
  
  
     qi::rule<It, Skipper> notOperator_
@@ -129,11 +153,14 @@ private:
         , greaterOperator_ 
         , greaterOrEqualOperator_ 
         ,lowerOrEqualOperator_
+        ,componentOperator_
         ,lowerOperator_  ;
  
     qi::symbols<char, std::string> definedConstants;
-
     qi::symbols<char, std::string> definedParams;
+    qi::symbols<char, std::string> twoArgsFunction;
+    qi::symbols<char, std::string> oneArgsFunction;
+        qi::symbols<char, std::string> threeArgsFunction;
 };
  
 }