Pratt.hpp

Go to the documentation of this file.

#pragma once
 
#include "Lex.hpp"
 
#include <unordered_map>
 
namespace iv
{
 
class Pratt
{
public:
    struct Unary;
    struct Binary;
    struct Value;
    
    struct Expression
    {
        int line;
        int column;
        
        int name;
        
        virtual ~Expression(){}
        virtual Unary const * ToUnary() const   { return nullptr; }
        virtual Binary const * ToBinary() const { return nullptr; }
        virtual Value const * ToValue() const { return nullptr; }
    };
    
    struct Unary : public Expression
    {
        Expression const * child;
        
        virtual Unary const * ToUnary() const override { return this; }
    };
 
    struct Binary : public Expression
    {
        Expression const * left;
        Expression const * right;
        
        virtual Binary const * ToBinary() const override { return this; }
    };
    
    struct Value : public Expression
    {
        Lex::Token token;
        std::string token_str;
        
        virtual Value const * ToValue() const override { return this; }
    };
 
public:
ClientMarker cm;
 
                    Pratt( Instance * inst );
                    ~Pratt();
 
    Instance *      instance();
 
    //------------- define expression structure ------------------------------------------------------
    void            def_unary( int name, int precedence, const char * op_left, bool child_mandatory, const char * op_right, bool phantom=false );
    
    void            def_binary( int name, int precedence, const char * op_left, bool left_child_mandatory, const char * op_middle, bool right_child_mandatory, const char * op_right );
    void            def_value( int name );
    
    //----------------------------------------------------------------------------------------------------------
    void            define_operators( Lex * lex );
    
    void            read_expression( Lex * lex );
    
    void            clear();
    
    //------------------------------------------------------------------------------------------------------
    Expression const *  root();
 
//------------------------------------------------------------------------------------------------------
private:
    Expression *    expr( int precedence, const char * terminator );
    
private:
    struct Def
    {
        int name;
        int precedence;
        bool unary;
        bool phantom;                   
        
        std::string op_left;
        bool child_mandatory;
        std::string op_middle;          
        bool right_child_mandatory;     
        std::string op_right;
    };
    
private:
    Instance * inst;
    Lex * lex;
    Expression * _root;
    std::unordered_set< Def * > defs;
    
    std::unordered_set< std::string > operators;
    
    std::unordered_map< std::string, Def * > defs_prefix;   
    std::unordered_map< std::string, Def * > defs_nonprefix;    
    int value_name;
};
 
}