gateExpression.h

Go to the documentation of this file.

#pragma once

#include "signatureConstants.h"
#include <string>

namespace expr {

    enum ExpressionType {
        ExprVar,        
        ExprConst,      
        ExprLongConst,  
        ExprBinOp,      
        ExprUnOp,       
        ExprUnOpCst,    
        ExprSlice,      
        ExprMerge,      
    };

    /***********************************************************************/
    /* WARNING! The following enums are duplicated (on purpose) inside the */
    /* C API. Change this API as well if you are to change these enums!    */
    /***********************************************************************/

    enum ExpressionBinOperator {
        BAnd,           
        BOr,            
        BXor,           
        BAdd,           
        BSub,           
        BMul,           
        BDiv,           
        BMod,           
        BLsr,           
        BLsl,           
        BAsr,           
    };

    enum ExpressionUnOperator {
        UNot,           
    };

    enum ExpressionUnOperatorCst {
        UCLsr,          
        UCLsl,          
        UCAsr,          
    };

};

class BadHex : public std::exception {};

struct ExpressionBase {
    ExpressionBase(const expr::ExpressionType& type)
        : type(type), refcount(0) {}
    virtual ~ExpressionBase() {}
    expr::ExpressionType type;    

    virtual sign_t sign() const = 0; // FIXME memoize?

    bool equals(const ExpressionBase& oth) const;

    inline void addRef() {
        refcount++;
    }

    void deleteSelf() {
        refcount--;
        if(refcount == 0)
            delete this;
    }

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const = 0;

    protected:
        int refcount;
};

struct ExpressionConst : ExpressionBase {
    ExpressionConst(unsigned val)
        : ExpressionBase(expr::ExprConst), val(val) {}

    unsigned val;           

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionLongConst : ExpressionBase {
    ExpressionLongConst(const std::string& val)
        : ExpressionBase(expr::ExprConst), val(val)
    {
        for(const auto& ch: this->val) {
            if(!('0' <= ch && ch <= '9')
                    && !('a' <= ch && ch <= 'f')
                    && !('A' <= ch && ch <= 'F'))
                throw BadHex();
        }
    }

    std::string val;           

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionVar : ExpressionBase {
    ExpressionVar(int id) : ExpressionBase(expr::ExprVar), id(id) {}

    int id;                 

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionBinOp : public ExpressionBase {
    ExpressionBinOp(ExpressionBase* left,
            ExpressionBase* right,
            expr::ExpressionBinOperator op) :
        ExpressionBase(expr::ExprBinOp), left(left), right(right), op(op)
    {
        left->addRef();
        right->addRef();
    }
    virtual ~ExpressionBinOp() {
        left->deleteSelf();
        right->deleteSelf();;
    }

    ExpressionBase *left, *right;
    expr::ExpressionBinOperator op;       

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionUnOp : ExpressionBase {
    ExpressionUnOp(ExpressionBase* expr, expr::ExpressionUnOperator op) :
       ExpressionBase(expr::ExprUnOp), expr(expr), op(op)
    {
        expr->addRef();
    }
    virtual ~ExpressionUnOp() {
        expr->deleteSelf();
    }

    ExpressionBase *expr;           
    expr::ExpressionUnOperator op;  

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionUnOpCst : ExpressionBase {
    ExpressionUnOpCst(ExpressionBase* expr,
            int val,
            expr::ExpressionUnOperatorCst op) :
        ExpressionBase(expr::ExprUnOpCst), expr(expr), val(val), op(op)
    {
        expr->addRef();
    }
    virtual ~ExpressionUnOpCst() {
        expr->deleteSelf();
    }

    ExpressionBase *expr;
    int val;                            
    expr::ExpressionUnOperatorCst op;   

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionSlice : ExpressionBase {
    ExpressionSlice(ExpressionBase* expr, unsigned beg, unsigned end) :
        ExpressionBase(expr::ExprSlice), expr(expr), beg(beg), end(end)
    {
        expr->addRef();
    }
    virtual ~ExpressionSlice() {
        expr->deleteSelf();
    }

    ExpressionBase *expr;
    unsigned beg;           
    unsigned end;           

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};

struct ExpressionMerge : ExpressionBase {
    ExpressionMerge(ExpressionBase* left, ExpressionBase* right) :
        ExpressionBase(expr::ExprMerge), left(left), right(right)
    {
        left->addRef();
        right->addRef();
    }
    virtual ~ExpressionMerge() {
        left->deleteSelf();
        right->deleteSelf();
    };

    ExpressionBase *left, *right;

    virtual sign_t sign() const;

    private:
        virtual bool innerEqual(const ExpressionBase& oth) const;
};