Expression.hh

Go to the documentation of this file.

#ifndef __DIADES__ALTARICA_EXPRESSION__HH
#define __DIADES__ALTARICA_EXPRESSION__HH

#include<vector>
#include<arsyntax/altarica-tree.h>
#include<diades/utils/Exceptions.hh>
#include<diades/altarica/Value.hh>
#include<diades/altarica/Domains.hh>
#include<diades/altarica/VariableDecl.hh>
#include<diades/altarica/Type.hh>

namespace Diades
{
  namespace Altarica
  {
  
        /*****************************************************/
        class AltaricaModel;
        class NodeDecl;
        
        class Expression {
        public:
          typedef enum {IfThenElse=0,Case=1,Or=2,And=3,Eq=4,Neq=5,Imply=6,Lt=7,Gt=8,Leq=9,Geq=10,Add=11,Sub=12,Mul=13,Div=14,Mod=15,Neg=16,Not=17,Paren=18,StructMember=19,ArrayMember=20,Var=21,Id=22,Min=23,Max=24,True=25,False=26,Integer=27,ForAll=28,Exist=29,FunctionCall=30,Struct=31,Array=32} Category;


          typedef  reference_wrapper<Expression const>  ConstReference;
          typedef  reference_wrapper<Expression>  Reference;
          typedef std::vector<ConstReference> ExprVector;


          
        public:
          typedef Utils::Exception<Expression> Exception;
          static string typeName() { return "Altarica::Expression"; }
        
        public:
          typedef std::vector<VariableDecl::ConstReference>::const_iterator VariableIterator;
          typedef std::vector<VariableDecl::ConstReference>::size_type SizeType;
          typedef std::vector<VariableDecl::ConstReference> Support;
        protected:
          Support _varSupport; 

          const NodeDecl & _owner;
          unsigned     _id;
          //mutable Type::ConstReference    _returnedType;
        public:

          virtual ~Expression()
          {
                _varSupport.clear();
          }
          
          const AltaricaModel & model() const;

          const NodeDecl & owner() const;


          bool operator==(const Expression & e) const
          {
                return this == &e;
          }


          Expression(const  NodeDecl & owner,unsigned id);
          
          
          // /**
          //     Expression evaluation: this operation evaluates the expression with
          //     the current value associated to the variables that support the Expression.
          //     The evaluation is failing if there is a variable of the support that is
          //     still free (that is an unassigned variable).
          //     @param value the Value resulting from the evaluation of the current
          //     Expression.
          //     @return true if the operation succeeds, false otherwise.
          // **/
          // virtual bool eval(Value & value) const = 0;

          virtual Category category() const = 0;


          unsigned id() const { return _id; }
          

          virtual bool valid() const = 0;

          VariableIterator variableBegin() const { return _varSupport.begin(); }

          VariableIterator variableEnd() const   { return _varSupport.end(); }

          SizeType supportSize() const
          {
                return _varSupport.size();
          }

          const Support & support() const
          {
                return _varSupport;
          }

          virtual const Type & valueType() const = 0;

          virtual bool isConstant() const = 0;
        
          friend ostream & operator<<(ostream & os, const Expression & expr);

        
          //friend class NodeInstance;
        };

        bool mergeExpressionSupports(const Expression::ExprVector & expr,
                                                                 vector<VariableDecl::ConstReference> & mergedSupport);

        void appendExpressionSupports(const Expression::ExprVector & expr,
                                                                  vector<VariableDecl::ConstReference> & appendedSupport);


        
        class NullExpression : public Expression
        {


        public:
          NullExpression(NodeDecl & owner);
          virtual bool isConstant() const { return true; }
          virtual const Type & valueType() const;
          virtual Category category() const { return False; }
          virtual bool valid() const { return false; }
          virtual ~NullExpression(){}
        };

        /*****************************************************/

        
        class IteExpression: public Expression
        {
        private:
          const Expression & _if;
          const Expression & _then;
          const Expression & _else; 
        public:
          IteExpression(const NodeDecl & owner,unsigned id, const Expression & ifE, const Expression & thenE, const Expression & elseE);
          virtual bool valid() const { return _if.valid() && _then.valid() && _else.valid(); } 
          Category category() const { return IfThenElse; }
          //bool eval(Value & result) const;

          virtual const Type & valueType() const
          {
                return _then.valueType();
          }
          const Expression & ifExpr() const { return _if; }
          const Expression & thenExpr() const { return _then; }
          const Expression & elseExpr() const { return _else; }

          virtual bool isConstant() const
          {
                return ifExpr().isConstant() &&  thenExpr().isConstant() && elseExpr().isConstant();
          }

          virtual ~IteExpression(){}
          
          friend ostream & operator<<(ostream & os, const Expression & expression);
          //friend class NodeInstance;
        };

        /*****************************************************/


        class CaseExpression: public Expression
        {
        private:
          ExprVector _choices;
          ExprVector _expressions;
        public:
          typedef ExprVector::size_type AlternativeIndex;
        public:
          CaseExpression(const NodeDecl & owner,unsigned id,const ExprVector & choices,
                                         const ExprVector & expressions);
          AlternativeIndex first() const {
                return 0;
          }

          AlternativeIndex last() const {
                return _choices.size() - 1;
          }

          const Expression & getAlternative(AlternativeIndex index) const
          {
                return _choices[index];
          }
          const Expression & getAlternativeExpression(AlternativeIndex index) const
          {
                return _expressions[index];
          }

          const Expression & defaultCase() const { return _expressions.back(); }
          virtual bool valid() const
          {
                bool result = !_choices.empty() && (_choices.size() == _expressions.size()-1);
                unsigned index = 0;
                while(result && (index < _choices.size()))
                  {
                        result = _choices[index].get().valid() && _expressions[index].get().valid();
                        ++index;
                  }
                if(result)
                  {
                        result = _expressions[_expressions.size()-1].get().valid();
                  } 
                return result;
          }
          Category category() const { return  Case; }
          //bool eval(Value & result) const;
          virtual const Type & valueType() const
          {
                return  defaultCase().valueType();
          }
          virtual bool isConstant() const
          {
                bool result = true;
                for(AlternativeIndex index = first(); index<= last(); ++index)
                  {
                        result = result && getAlternative(index).isConstant()
                          && getAlternativeExpression(index).isConstant();
                  }
                result = result && defaultCase().isConstant();
                return result;
          }

          virtual ~CaseExpression()
          {
                _choices.clear();
                _expressions.clear();
          }
          
          friend ostream & operator<<(ostream & os, const Expression & expression);
          //friend class NodeInstance;
        };
  
        /*****************************************************/


        
        class BinaryExpression: public Expression
        {
        public:
          typedef Value::BinaryOperator Operator;
          
        private:
          const Expression & _left;
          const Expression & _right;
          Category _category;
          Operator _op;
        public:
          BinaryExpression(const NodeDecl & owner,unsigned id,
                                           const Expression & left,
                                           const Expression & right,
                                           Category category);
          virtual bool valid() const
          {
                return _left.valid() && _right.valid();
          }
          Operator op() const { return _op; } 
          const Expression & left() const { return _left; }
          const Expression & right() const { return _right; }
          Category category() const { return _category; }
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return left().isConstant() && right().isConstant();
          }
          virtual ~BinaryExpression(){}
        };


        /*****************************************************/


        class UnaryExpression: public Expression
        {
        private:
          const Expression & _expr;
          Category _category;
        public:
          UnaryExpression(const NodeDecl & owner, unsigned id,const Expression & expr,Category category);
          Category category() const { return _category; }
          virtual bool valid() const
          {
                return   _expr.valid();
          }
          virtual const Type & valueType() const
          {
                return _expr.valueType();
          }
          const Expression & expression() const
          {
                return _expr;
          }
          virtual bool isConstant() const
          {
                return expression().isConstant();
          }
          virtual ~UnaryExpression(){}
        };











        
        // /*****************************************************/



        /*****************************************************/ 

        class StructMemberExpression: public Expression
        {
        private:
          const Expression & _structure;
          const Expression & _field;
        public:
          StructMemberExpression(const NodeDecl & owner, unsigned id, const Expression & structure,
                                                         const Expression & field);
          Category category() const { return StructMember; }
        
          //VariableDecl getVariableDecl() const;
          virtual bool valid() const
          {
                return   _structure.valid() &&  _field.valid();
          }
          // bool eval(Value & result) const;
           const Expression &  getStructure() const
          {
                return _structure;
          }
           const Expression &  getMember() const
          {
                return _field;
          }
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return false;
          }
        };


        /*****************************************************/ 

        class ArrayMemberExpression: public Expression
        {
        private:
          const Expression & _array;
          const Expression & _exprField;
        
        public:
          ArrayMemberExpression(const NodeDecl & owner, unsigned id,const Expression & array, const Expression & exprField);
          const Expression & arrayExpr() const
          {
                return _array;
          }
          const Expression & indexExpr() const
          {
                return _exprField;
          }
          const Expression & left() const
          {
                return arrayExpr();
          }
          const Expression & right() const
          {
                return indexExpr();
          }
          Category category() const { return  ArrayMember; }
          // bool eval(Value & result) const;
          virtual bool valid() const
          {
                return  (_array.valid()  && _exprField.valid());
          }
          //VariableDecl getVariableDecl() const;
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return false;
          }
          friend ostream & operator<<(ostream & os, const Expression & expression);
          //friend class NodeInstance;
        };


        /*****************************************************/ 

        class VarExpression: public Expression
        {
        public:
          VarExpression(const NodeDecl & owner, unsigned id,const VariableDecl & var);
          Category category() const { return Var; }
          virtual bool valid() const { return !_varSupport.begin()->get().isNull(); }
          const VariableDecl & getVariableDecl() const { return *variableBegin(); }
          // bool eval(Value & result) const;

          virtual const Type & valueType() const
          {
                return getVariableDecl().type();
          }
          virtual bool isConstant() const
          {
                return false;
          }
          virtual ~VarExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
        };


        /*****************************************************/ 

        
        class IdExpression: public Expression
        {
        private:
          Identifier _ident;

        public:
          IdExpression(const NodeDecl & owner, unsigned id,const Identifier & identifier);
          const Identifier & identifier() const { return _ident; }
          virtual bool valid() const
          {
                return !_ident.str().empty();
          }
          Category category() const { return Id; } 
          // bool eval(Value & result) const;
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return true;
          }
          virtual ~IdExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
          //friend class NodeInstance;
        };


        /*****************************************************/ 

        class MinMaxExpression : public Expression
        {
        private:
          ExprVector _body;
          Category _category;
        public:
          MinMaxExpression(const NodeDecl & owner, unsigned id,const ExprVector & body,Category category);
          Category category() const { return  _category; }
         ExprVector::const_iterator bodyBegin() const
          {
                return _body.begin();
          }
          ExprVector::const_iterator bodyEnd() const
          {
                return _body.end();
          }
          virtual bool valid() const
          {
                bool result = !_body.empty();
                unsigned index = 0;
                while(result && (index < _body.size()))
                  {
                        result =  _body[index].get().valid();
                        ++index;
                  }
                return result;
          }
          // bool eval(Value & result) const;
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                bool result = true;
                ExprVector::size_type index = 0;
                while(result && (index < _body.size()-1))
                  {
                        result = _body[index].get().isConstant();
                        ++index;
                  }
                return result;
          }
          virtual ~MinMaxExpression()
          {
                _body.clear();
          }
          friend ostream & operator<<(ostream & os, const Expression & expression);
        };



        /*****************************************************/ 

        class TrueExpression : public Expression
        {
 
    
        public:
          TrueExpression(const NodeDecl & owner, unsigned id);
          Category category() const { return True; }
          virtual bool valid() const { return true; }
          // bool eval(Value & result) const;
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return true;
          }
          virtual ~TrueExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
          //friend class NodeInstance;
        };



        /*****************************************************/ 

        class FalseExpression : public Expression
        {
        private:
    
        public:
          FalseExpression(const NodeDecl & owner, unsigned id);
          Category category() const { return False; }
          // bool eval(Value & result) const;
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return true;
          }
          virtual bool valid() const { return true; }
          virtual ~FalseExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
        };



        /*****************************************************/ 


        class IntegerExpression : public Expression
        {
        private:
          int _value;
        public:
          IntegerExpression(const NodeDecl & owner, unsigned id, int value);
          Category category() const { return Integer; }
          // bool eval(Value & result) const;
          virtual bool valid() const { return true; }
          virtual const Type & valueType() const;

          virtual bool isConstant() const
          {
                return true;
          }
          int integer() const { return _value; }
          virtual ~IntegerExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
        };


        /*****************************************************/ 


        class ForAllExpression : public Expression
        {
        private:
        public:
          Category category() const { return ForAll; }
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return false;
          }
          virtual ~ForAllExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
        };


        /*****************************************************/ 

  
        class ExistExpression : public Expression
        {
        private:
        public:
          Category category() const { return Exist; }
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return false;
          }
          virtual ~ExistExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
        }; 

        /*****************************************************/ 
   
        class FunctionCallExpression : public Expression
        {
        private:
          //Function * _func;
          vector<VariableDecl> _param;
        public:
          Category category() const { return FunctionCall; }
          // bool eval(Value & result) const;
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                return false;
          }
          virtual ~FunctionCallExpression(){}
          friend ostream & operator<<(ostream & os, const Expression & expression);
          //friend class NodeInstance;
        };


        /*****************************************************/ 

  
        class StructExpression : public Expression
        {
        private:
          vector<Identifier> _identifiers;
          ExprVector _expressions;
        public:
          StructExpression(const NodeDecl & owner, unsigned id,const vector<Identifier> & identifiers,
                                           const ExprVector & expressions);       
          vector<Identifier>::size_type size() const
          {
                return _identifiers.size();
          }


          const Identifier & identifierOfIndex(vector<Identifier>::size_type index) const
          {
                return _identifiers[index];
          }
          const Expression & expressionOfIndex(ExprVector::size_type index) const
          {
                return _expressions[index];
          }

          
          Category category() const { return Struct; }
          // bool eval(Value & result) const;
          virtual bool valid() const
          {
                bool result = !_identifiers.empty() && (_identifiers.size() == _expressions.size());
                unsigned index = 0;
                while(result && (index < _identifiers.size()))
                  {
                        result = (!_identifiers[index].str().empty()) && (_expressions[index].get().valid());
                        ++index;
                  }
                return result;
          }
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                bool result = true;
                ExprVector::size_type index = 0;
                while(result && (index != size()))
                  {
                        result = _expressions[index].get().isConstant();
                        ++index;
                  }
                return result;
          }
          virtual ~StructExpression(){ _identifiers.clear(); _expressions.clear(); }
        };


        /*****************************************************/ 

  
        class ArrayExpression : public Expression
        {
        private:
          ExprVector _array;
        public:
          ArrayExpression(const NodeDecl & owner, unsigned id,const ExprVector & array);
          Category category() const { return Array; }
          // bool eval(Value & result) const;
          
          ExprVector::const_iterator bodyBegin() const
          {
                return _array.begin();
          }
          ExprVector::const_iterator bodyEnd() const
          {
                return _array.end();
          }
          ExprVector::size_type size() const
          {
                return _array.size();
          }
        
          
          virtual bool valid() const
          {
                bool result = !_array.empty();
                unsigned index = 0;
                while(result && (index < _array.size()))
                  {
                        result = _array[index].get().valid();
                        ++index;
                  }
                return result;
          }   
          virtual const Type & valueType() const;
          virtual bool isConstant() const
          {
                bool result = true;
                ExprVector::size_type index = 0;
                while(result && (index != _array.size()))
                  {
                        result = _array[index].get().isConstant();
                        ++index;
                  }
                return result;
          }
          virtual ~ArrayExpression(){ _array.clear(); }
        };


        const Expression & nullExpression();
        
  };
};




#endif