operators.h

/*********************************************************************
 *
 * Condor ClassAd library
 * Copyright (C) 1990-2003, Condor Team, Computer Sciences Department,
 * University of Wisconsin-Madison, WI and Rajesh Raman.
 *
 * This source code is covered by the Condor Public License, which can
 * be found in the accompanying LICENSE file, or online at
 * www.condorproject.org.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * AND THE UNIVERSITY OF WISCONSIN-MADISON "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, OF SATISFACTORY QUALITY, AND FITNESS
 * FOR A PARTICULAR PURPOSE OR USE ARE DISCLAIMED. THE COPYRIGHT
 * HOLDERS AND CONTRIBUTORS AND THE UNIVERSITY OF WISCONSIN-MADISON
 * MAKE NO MAKE NO REPRESENTATION THAT THE SOFTWARE, MODIFICATIONS,
 * ENHANCEMENTS OR DERIVATIVE WORKS THEREOF, WILL NOT INFRINGE ANY
 * PATENT, COPYRIGHT, TRADEMARK, TRADE SECRET OR OTHER PROPRIETARY
 * RIGHT.
 *
 *********************************************************************/

#ifndef __OPERATORS_H__
#define __OPERATORS_H__

#include "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);

                ~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;

                // 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//__OPERATORS_H__