operators.h

/***************************************************************
 *
 * Copyright (C) 1990-2007, Condor Team, Computer Sciences Department,
 * University of Wisconsin-Madison, WI.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 * 
 *    http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ***************************************************************/


#ifndef __CLASSAD_OPERATORS_H__
#define __CLASSAD_OPERATORS_H__

#include "classad/exprTree.h"

BEGIN_NAMESPACE( classad )


class Operation : public ExprTree
{
    public:
        enum OpKind
        { __NO_OP__,              // convenience

            __FIRST_OP__,

            __COMPARISON_START__    = __FIRST_OP__, LESS_THAN_OP = __COMPARISON_START__,  LESS_OR_EQUAL_OP,       // (comparison)  NOT_EQUAL_OP,           // (comparison)  EQUAL_OP,               // (comparison)  GREATER_OR_EQUAL_OP,    // (comparison)  GREATER_THAN_OP,        // (comparison)
 META_EQUAL_OP,        // (comparison)  IS_OP= META_EQUAL_OP,   // (comparison)META_NOT_EQUAL_OP,//(comparison)  ISNT_OP=META_NOT_EQUAL_OP,//(comparison)
            __COMPARISON_END__      = ISNT_OP,

            __ARITHMETIC_START__,  UNARY_PLUS_OP = __ARITHMETIC_START__,  UNARY_MINUS_OP,         // (arithmetic)  ADDITION_OP,            // (arithmetic)  SUBTRACTION_OP,         // (arithmetic)  MULTIPLICATION_OP,      // (arithmetic)  DIVISION_OP,            // (arithmetic)  MODULUS_OP,             // (arithmetic)
            __ARITHMETIC_END__      = MODULUS_OP,

            __LOGIC_START__,  LOGICAL_NOT_OP = __LOGIC_START__,  LOGICAL_OR_OP,          // (logical)  LOGICAL_AND_OP,         // (logical)
            __LOGIC_END__           = LOGICAL_AND_OP,

            __BITWISE_START__,  BITWISE_NOT_OP = __BITWISE_START__,  BITWISE_OR_OP,          // (bitwise)  BITWISE_XOR_OP,         // (bitwise)  BITWISE_AND_OP,         // (bitwise)  LEFT_SHIFT_OP,          // (bitwise)  RIGHT_SHIFT_OP,         // (bitwise) URIGHT_SHIFT_OP,        // (bitwise)
            __BITWISE_END__         = URIGHT_SHIFT_OP,

            __MISC_START__,  PARENTHESES_OP = __MISC_START__,  SUBSCRIPT_OP,           // (misc)  TERNARY_OP,             // (misc)
            __MISC_END__            = TERNARY_OP,

            __LAST_OP__             = __MISC_END__
        };

        Operation(const Operation &op);

        virtual ~Operation ();

        Operation &operator=(const Operation &op);

        static Operation *MakeOperation(OpKind kind,ExprTree*e1=NULL,
                    ExprTree*e2=NULL, ExprTree*e3=NULL);

        void GetComponents( OpKind&, ExprTree*&, ExprTree*&, ExprTree *& )const;

        // public access to operation function
        static void Operate (OpKind op, Value &op1, Value &op2, Value &result);

        static void Operate (OpKind op, Value &op1, Value &op2, Value &op3, 
            Value &result);

        static bool IsStrictOperator( OpKind );

        static int PrecedenceLevel( OpKind );

        virtual ExprTree* Copy( ) const;

        bool CopyFrom(const Operation &op);

        virtual bool SameAs(const ExprTree *tree) const;

        friend bool operator==(const Operation &op1, const Operation &op2);

    protected:
        Operation ();

    private:
        bool SameChild(const ExprTree *tree1, const ExprTree *tree2) const;

        virtual void _SetParentScope( const ClassAd* );
        virtual bool _Evaluate( EvalState &, Value &) const;
        virtual bool _Evaluate( EvalState &, Value &, ExprTree*& ) const;
        virtual bool _Flatten( EvalState&, Value&, ExprTree*&, int* ) const;

            // returns true if result is determined for this operation
            // based on the evaluated arg1
        bool shortCircuit( EvalState &state, Value const &arg1, Value &result ) const;

        // auxillary functionms
        bool combine( OpKind&, Value&, ExprTree*&, 
                int, Value&, ExprTree*, int, Value&, ExprTree* ) const;
        bool flattenSpecials( EvalState &, Value &, ExprTree *& ) const;

        static Operation* MakeOperation( OpKind, Value&, ExprTree* );
        static Operation* MakeOperation( OpKind, ExprTree*, Value& );
        static Value::ValueType coerceToNumber (Value&, Value &);

        enum SigValues { SIG_NONE=0, SIG_CHLD1=1 , SIG_CHLD2=2 , SIG_CHLD3=4 };

        static int _doOperation(OpKind,Value&,Value&,Value&,
                                bool,bool,bool,  Value&, EvalState* = NULL);
        static int  doComparison        (OpKind, Value&, Value&, Value&);
        static int  doArithmetic        (OpKind, Value&, Value&, Value&);
        static int  doLogical           (OpKind, Value&, Value&, Value&);
        static int  doBitwise           (OpKind, Value&, Value&, Value&); 
        static int  doRealArithmetic    (OpKind, Value&, Value&, Value&);
        static int  doTimeArithmetic    (OpKind, Value&, Value&, Value&);
        static void compareStrings      (OpKind, Value&, Value&, Value&,bool);
        static void compareReals        (OpKind, Value&, Value&, Value&);
        static void compareBools        (OpKind, Value&, Value&, Value&);
        static void compareIntegers     (OpKind, Value&, Value&, Value&);
        static void compareAbsoluteTimes(OpKind, Value&, Value&, Value&);
        static void compareRelativeTimes(OpKind, Value&, Value&, Value&);

        // operation specific information
        OpKind      operation;
        ExprTree    *child1;
        ExprTree    *child2;
        ExprTree    *child3;
};

END_NAMESPACE // classad

#endif//__CLASSAD_OPERATORS_H__