expressions.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_PARSING_EXPRESSIONS_H
#define ELEMENTA_PARSING_EXPRESSIONS_H
 
#include <limits>
#include <vector>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <functional>
#include "elementa/base/enums.h"
#include "elementa/base/exceptions.h"
 
namespace elementa
{
 
namespace parsing
{
 
/* ***************************************************************************
 
    Abstract base classes: ExprElement, ExprOperElement
    Concrete classes: ExprSimpleGroupOpen, ExprSimpleGroupClose, ExprOperNop
 
*******************************************************************************/
 
 
class ExprElement
{
 public:
 
    using Ptr = std::shared_ptr<ExprElement>;
 
 
    class PList: public std::list<Ptr>
    {
     public: 
 
        using Base = std::list<Ptr>;
 
        using Base::Base;
 
        virtual std::string to_string(void) const;
    };
 
    ELE_CLASS_ENUM(Kind,
                    kDatum,     
                    kGroupOpen, 
                    kGroupClose,
                    kArgsOpen,  
                    kArgsClose, 
                    kArgsSep,   
                    kOperation  
                    );
 
    virtual ~ExprElement(void) = default;
 
    bool isDatum(void) const noexcept { return(kind() == Kind::kDatum); }
 
    bool isOperation(void) const noexcept { return(kind() == Kind::kOperation);}
 
    bool isOpeningGrouping(void) const noexcept 
        { return(kind() == Kind::kGroupOpen); }
 
    bool isClosingGrouping(void) const noexcept 
        { return(kind() == Kind::kGroupClose); }
 
    bool isGrouping(void) const noexcept 
        { return(isOpeningGrouping() || isClosingGrouping()); }
 
    bool isOpeningArgs(void) const noexcept 
        { return(kind() == Kind::kArgsOpen); }
 
    bool isClosingArgs(void) const noexcept 
        { return(kind() == Kind::kArgsClose); }
 
    bool isGroupingArgs(void) const noexcept 
        { return(isOpeningArgs() || isClosingArgs()); }
 
    bool isSepArgs(void) const noexcept 
        { return(kind() == Kind::kArgsSep); }
          
    bool isDatumTypedAs(int ty) const noexcept
        { return(isDatum() && (type() == ty)); }
 
    virtual Kind kind(void) const = 0;
 
 
    virtual int type(void) const { return(-1); }
 
    // Can be overriden to return a more specific text version of the element.
    virtual std::string to_string(void) const
        { return(KindEnum::IdName(kind())); }
 
};
 
 
class ExprSimpleGroupOpen: public ExprElement
{
 public:
 
    Kind kind(void) const { return(Kind::kGroupOpen); }
};
 
 
class ExprSimpleGroupClose: public ExprElement
{
 public:
 
    Kind kind(void) const { return(Kind::kGroupClose); }
};
 
class ExprSimpleArgsOpen: public ExprElement
{
 public:
 
    Kind kind(void) const { return(Kind::kArgsOpen); }
};
 
class ExprSimpleArgsClose: public ExprElement
{
 public:
 
    Kind kind(void) const { return(Kind::kArgsClose); }
};
 
class ExprSimpleArgsSep: public ExprElement
{
 public:
 
    Kind kind(void) const { return(Kind::kArgsSep); }
};
 
 
class ExprOperElement: public ExprElement
{
 public:
    
    ELE_CLASS_ENUM(ArgsGroupOmitting,
                    CanOmit,
                    MustOmit,
                    CannotOmit);
 
 
    class ParamSpec: public std::vector<int> 
    {
     public:
 
        using Base = std::vector<int>;
 
        using Base::Base;
 
        std::string to_string(void) const;
    };
 
 
    using VectorOfParamSpecs = std::vector<ParamSpec>;
 
    Kind kind(void) const { return(Kind::kOperation); }
 
 
    unsigned char arity(void) const
        { ParamSpec::size_type ps{prototype().size()};
          if (ps == 0) return(0);
          if (ps > static_cast<ParamSpec::size_type>(
                    std::numeric_limits<unsigned char>::max()))
            ELE_CODE_INVSTATE(
                    "Operator with too many parameters (" + std::to_string(ps) +
                    ", prototype " + prototype().to_string() + 
                    ") in its specification");
          return(static_cast<unsigned char>(withResult() ? ps-1 : ps)); }
          
 
    virtual bool inFixed(void) const { return(true); }
    
 
    virtual ArgsGroupOmitting argGroupingsOmit(void) const 
        { return(ArgsGroupOmitting::CannotOmit); }
    
    virtual ExprElement::Ptr argsOpening(void) const 
        { return(ExprElement::Ptr{new ExprSimpleArgsOpen{}}); }
 
    virtual ExprElement::Ptr argsClosing(void) const 
        { return(ExprElement::Ptr{new ExprSimpleArgsClose{}}); }
 
    virtual ExprElement::Ptr argsSeparating(void) const 
        { return(ExprElement::Ptr{new ExprSimpleArgsSep{}}); }
 
 
    virtual const ParamSpec & prototype(void) const = 0;
 
 
    virtual unsigned precedence(void) const = 0;
 
 
    virtual bool withResult(void) const { return(true); }
 
};
 
 
class ExprOperNop: public ExprOperElement
{
 public:
    
    const ParamSpec & prototype(void) const
        {const static ParamSpec nopps; return(nopps); }
    unsigned precedence(void) const { return(0); } // ignored
    bool withResult(void) const override { return(false); }
 
    ArgsGroupOmitting argGroupingsOmit(void) const override 
        { return(ArgsGroupOmitting::MustOmit); }
 
    std::string to_string(void) const override { return("NOP"); }
 
};
 
 
/* ***************************************************************************
 
    Class: Expression
 
*******************************************************************************/
 
 
class Expression: public ExprElement::PList
{
 public:
 
    using Base = ExprElement::PList;
 
    using Length = Base::size_type;
 
 
    ELE_CLASS_ENUM(Order,
                    kPostfix,   
                    kInfix      
                    );
 
 
    using Evaluator = 
        std::function< ExprElement::Ptr(const ExprElement::Ptr &,
                                        const ExprElement::PList &) >; 
                                        
 
    using TypeCompatChecker = 
        std::function< bool(const ExprOperElement &,
                            const ExprElement::Ptr &,
                            ExprOperElement::ParamSpec::Base::size_type,
                            int,int) >;
 
 
    using TypeConfirming = 
        std::function< int(ExprOperElement &,
                           const ExprOperElement::ParamSpec &,
                           int) >;
 
 
    static bool defaultTypeCompatChecker(
                            const ExprOperElement & oper,
                            const ExprElement::Ptr &,
                            ExprOperElement::ParamSpec::Base::size_type apos,
                            int tparm, int targ) 
        { return(tparm == targ); }
 
    static int defaultTypeConfirming(
                            ExprOperElement & oper,
                            const ExprOperElement::ParamSpec & actualproto,
                            int proposed)
        { return(proposed); }
 
 
    class EvalError: public elementa::base::Exc
    {
     public:
 
        EvalError(const std::string & explanation):
                            elementa::base::Exc{
                                std::string{"Expression evaluation error. "} + 
                                explanation} {}
                                
        ELE_CLASS_EXCOVERRIDE(EvalError)                                
    };
    
    class EmptyExpr: public EvalError
    {
     public:
 
        EmptyExpr(const std::string & details):
                        EvalError{elementa::base::concatWithMiddle(
                                    "Empty expression",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(EmptyExpr)            
    };
    
    class UnexpEnd: public EvalError
    {
     public:
 
        UnexpEnd(const std::string & details):
                        EvalError{elementa::base::concatWithMiddle(
                                    "Unexpected end of expression",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(UnexpEnd)         
    };  
        
    class GroupingError: public EvalError
    {
     public:
 
        GroupingError(const std::string & details):
                        EvalError{elementa::base::concatWithMiddle(
                                    "Grouping error",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(GroupingError)            
    };
 
    class MisusedElement: public EvalError
    {
     public:
 
        MisusedElement(const std::string & details):
                        EvalError{elementa::base::concatWithMiddle(
                                    "Misused element",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(MisusedElement)           
    };
 
    class InvArgs: public EvalError
    {
     public:
 
        InvArgs(const std::string & details):
                        EvalError{elementa::base::concatWithMiddle(
                                    "Invalid arguments",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(InvArgs)          
    };
 
    class InvResult: public EvalError
    {
     public:
 
        InvResult(const std::string & details):
                        EvalError{elementa::base::concatWithMiddle(
                                    "Invalid number of results",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(InvResult)            
    };
 
 
    class OpDatumWrapper: public ExprElement
    {
     public:
     
        char what; 
        ExprElement::Ptr pdatum; 
        struct {
                   ExprElement::Ptr poper; 
                   ExprElement::PList operands; 
               } oper; 
 
 
        ExprElement::Kind kind(void) const 
            { return(ExprElement::Kind::kDatum); }
            
        std::string to_string(void) const;
    };
 
 
    Expression(Order order = Order::kInfix,
               const ExprElement::Ptr & groupopening =
                ExprElement::Ptr{new ExprSimpleGroupOpen{}},
               const ExprElement::Ptr & groupclosing =
                ExprElement::Ptr{new ExprSimpleGroupClose{}}):
                                                    Base{},
                                                    groupopen_{groupopening},
                                                    groupclose_{groupclosing},
                                                    order_{order} {}
 
 
    Expression(Order order, Base && elems, 
               const ExprElement::Ptr & groupopening =
                ExprElement::Ptr{new ExprSimpleGroupOpen{}},
               const ExprElement::Ptr & groupclosing =
                ExprElement::Ptr{new ExprSimpleGroupClose{}}):
                                                    Base{std::move(elems)},
                                                    groupopen_{groupopening},
                                                    groupclose_{groupclosing},
                                                    order_{order} {}
                                                    
    Expression(const Expression & oth) { copyFrom(oth); }
    Expression(Expression && oth) { moveFrom(std::move(oth)); }
    Expression & operator=(const Expression & oth) 
        { if (this != &oth) copyFrom(oth); return(*this); }                                                     
    Expression & operator=(Expression && oth) 
        { if (this != &oth) moveFrom(std::move(oth)); return(*this); }                                                      
 
    Order order(void) const { return(order_); }
    
 
    ExprElement::Ptr buildTree(void) const;
 
 
    long checkGrouping(void) const;
    
    long checkArgGrouping(void) const;
    
 
    int checkType(Base::const_iterator & errloc,
                  const TypeCompatChecker & tcc = defaultTypeCompatChecker,
                  const TypeConfirming & tcf = defaultTypeConfirming) const;
 
 
    ExprElement::Ptr evaluate(Base::const_iterator & errloc,
                              Evaluator & evaluator) const;
                              
 
    bool reduce(Evaluator & evaluator);
 
 
    void changeOrder(Order neword, bool forcegrouping = false);
 
 
    void deleteNOPs(void);
 
 
    void changeElements(const std::function< std::pair<bool,ExprElement::Ptr>
                                                 (ExprElement::Ptr &) > & pred);
 
 
    void deleteElements(const std::function< bool(ExprElement::Ptr &) > & pred);
 
 private:
 
    using ConvIndex = std::pair<Order,Order>;
    using MapOfConversions = std::map < ConvIndex , 
                                        void (Expression::*)(bool) >;
 
    static const MapOfConversions mapofconvs_;
 
    ExprElement::Ptr groupopen_, groupclose_;
    Order order_;
 
    void copyFrom(const Expression & oth);
    void moveFrom(Expression && oth);
 
    void errorInvInPostfix(const std::string & context) const;
    long checkGeneralGrouping(ExprElement::Kind kopen, 
                              ExprElement::Kind kclose) const;
    void infixToPostfix(bool forcegrouping);
    void postfixToInfix(bool forcegrouping);
};
 
 // Expressions
 
} // End parsing namespace
 
} // End elementa namespace 
 
 
#endif