ExprUtil.h

Go to the documentation of this file.

#ifndef EXPRUTIL_H
#define EXPRUTIL_H

#include "NArgs.h"
//#include "Expression.h"

//BOREALIS_NAMESPACE_BEGIN
using namespace Borealis;

inline vector<ptr<Expression> > makeArgs(ptr<Expression> a = ptr<Expression>(),
                                          ptr<Expression> b = ptr<Expression>(),
                                          ptr<Expression> c = ptr<Expression>())
{
    vector<ptr<Expression> > out;
    
    if (a) { out.push_back(a); }
    if (b) { out.push_back(b); }
    if (c) { out.push_back(c); }
    
    return out;
}




// A Constant expression of type T.
template<typename T>
class ConstantExpression : public TypedExpression<T> {
  public:
    ConstantExpression(T val) : _val(val) {}
    T evalImpl(EvalAs<T>, const EvalContext& ctxt) throw (EvalException) { return _val; }

    T getValue() const { return _val; }
    string value() const { return to_string(_val); }

  private:
    T _val;
};

template<>
class ConstantExpression<EString> : public TypedExpression<EString> {
  public:
    ConstantExpression(string val) : _val(val) {}
    EString evalImpl(EvalAs<EString>, const EvalContext& ctxt) throw (EvalException) { return EString(_val); }

    string value() const { return "\"" + to_escaped_string(to_string(_val)) + "\""; }

  private:
    string _val;
};








// An expression returning the value, of type T, at a given offset in
// the input tuple.
template<typename T>
class FieldExpression : public TypedExpression<T> {
  public:
    FieldExpression(unsigned int which_tuple, unsigned int offset) :
        _which_tuple(which_tuple), _offset(offset) {}

    T evalImpl(EvalAs<T>, const EvalContext& ctxt) throw (EvalException) {
        return *(T*)(ctxt.getTuple(_which_tuple) + _offset);
    }

  private:
    unsigned int _which_tuple;
    unsigned int _offset;
};

template<>
class FieldExpression<EString> : public TypedExpression<EString> {
  public:
    FieldExpression(unsigned int which_tuple, unsigned int offset, unsigned int length) :
        _which_tuple(which_tuple), _offset(offset), _length(length) {}

    EString evalImpl(EvalAs<EString>, const EvalContext& ctxt) throw (EvalException) {
        const char *field = ctxt.getTuple(_which_tuple) + _offset;
        const char *end = field + _length;

        // ignore null padding at end
        while (end != field) {
            if (*(end - 1) != 0) break;
            --end;
        }            
        
        return EString(field, end - field);
    }

    int32 getStringLength() const { return _length; }

  private:
    unsigned int _which_tuple;
    unsigned int _offset, _length;
};







#define OP(N, Name, Out, Expr) \
template<typename T> \
class Name##Expression : public TypedExpression<Out>, NArgs { \
  public: \
    Name##Expression(const NArgs& args) throw (ExprException) : NArgs(args) { \
        requireNumArgs(N); \
    } \
    Out evalImpl(EvalAs<Out>, const EvalContext& ctxt) throw (EvalException) { \
        return Expr; \
    } \
}; \
struct Name##Expressions { \
    template <class T> struct forType { \
        typedef Name##Expression<T> ExprType; \
    }; \
};


template <class T>
inline T exprMod(T a, T b) { return a % b; }

template <>
inline single exprMod( single a, single b) { return( fmodf( a, b )); }

template <>
inline double exprMod( double a, double b) { return( fmod( a, b )); }


template <class T>
inline T divide(T a, T b) {
    if (b == 0) {
        WARN << "Divided by zero.";
        return numeric_limits<T>::infinity();
    } else {
        return a / b;
    }
}

// Actual operator declarations

#define A (_args[0]->template eval<T>(ctxt))
#define B (_args[1]->template eval<T>(ctxt))
#define C (_args[2]->template eval<T>(ctxt))

#define A_as(type) (_args[0]->template eval<type>(ctxt))

OP(2, Plus,   T,    A + B);
OP(2, Minus,  T,    A - B);
OP(2, Times,  T,    A * B);
OP(2, Div,    T,    divide(A,B));
OP(2, Mod,    T,    exprMod(A, B));
OP(2, Concat, T,    A.concat(B, ctxt.getPool()));

OP(2, EQ,     bool, A == B);
OP(2, NE,     bool, A != B);
OP(2, LT,     bool, A < B);
OP(2, GT,     bool, A > B);
OP(2, LE,     bool, A <= B);
OP(2, GE,     bool, A >= B);

OP(2, And,    bool, A && B);
OP(2, Or,     bool, A || B);

OP(1, UMinus, T,    -A);
OP(1, Not,    T,    !A);

OP(3, IfThenElse, T, A_as(bool) ? B : C);

#undef A
#undef B
#undef C



template <typename Types>
ptr<Expression> arithPromote( ptr<Expression>  l, ptr<Expression>  r )
                       throw( ExprException )
{
    if ( l->is_numeric() && r->is_numeric() )
    {   if (( l->getType() == DataType::DOUBLE )  ||
            ( r->getType() == DataType::DOUBLE ))
        {
            return( ptr<Expression>(
                        new typename Types::forType<double>::ExprType(
                                         NArgs( l, r ))));
        }
        else if (( l->getType() == DataType::SINGLE )  ||
                 ( r->getType() == DataType::SINGLE )  ||
                 ( r->getType() == DataType::FLOAT  )  ||   // bb: Depricated
                 ( r->getType() == DataType::FLOAT  ))
        {
            return( ptr<Expression>(
                        new typename Types::forType<single>::ExprType(
                                         NArgs( l, r ))));
        }
        else if (( l->getType() == DataType::LONG )  ||
                 ( r->getType() == DataType::LONG ))
        {
            return( ptr<Expression>(
                        new typename Types::forType<int64>::ExprType(
                                         NArgs( l, r ))));
        }
        else
        {   return( ptr<Expression>(
                        new typename Types::forType<int32>::ExprType(
                                         NArgs( l, r ))));
        }
    }

    Throw( ExprException, "invalid types" );
}   

template <typename Types>
ptr<Expression> relPromote( ptr<Expression>  l, ptr<Expression>  r )
                     throw( ExprException )
{
    if (( l->getType() == DataType::BOOL )  &&
        ( r->getType() == DataType::BOOL ))
    {
        return( ptr<Expression>(
                    new typename Types::forType<bool>::ExprType(
                                     NArgs( l, r ))));
    }
    else if ( l->is_numeric()  &&  r->is_numeric())
    {
        if (( l->getType() == DataType::DOUBLE )  ||
            ( r->getType() == DataType::DOUBLE ))
        {
            return( ptr<Expression>(
                        new typename Types::forType<double>::ExprType(
                                         NArgs( l, r ))));
        }
        else if (( l->getType() == DataType::SINGLE )  ||
                 ( r->getType() == DataType::SINGLE )  ||
                 ( r->getType() == DataType::FLOAT  )  ||   // bb: Depricated
                 ( r->getType() == DataType::FLOAT  ))
        {
            return( ptr<Expression>(
                        new typename Types::forType<single>::ExprType(
                                         NArgs( l, r ))));
        }
        else if (( l->getType() == DataType::LONG )  ||
                 ( r->getType() == DataType::LONG ))
        {
           return( ptr<Expression>(
                        new typename Types::forType<int64>::ExprType(
                                         NArgs( l, r ))));
        }
        else
        {   return( ptr<Expression>(
                        new typename Types::forType<int32>::ExprType(
                                         NArgs( l, r ))));
        }
    }
    else if (( l->getType() == DataType::STRING )  &&
             ( r->getType() == DataType::STRING ))
    {
        return( ptr<Expression>(
                    new typename Types::forType<EString>::ExprType(
                                     NArgs( l, r ))));
    }
    else
    {   Throw(ExprException, "invalid types");
    }
}

//BOREALIS_NAMESPACE_END
#endif                           // EXPRUTIL_H

---