exprTree.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_EXPR_TREE_H__
#define __CLASSAD_EXPR_TREE_H__

#include "classad/classad_stl.h"
#include "classad/common.h"
#include "classad/value.h"

BEGIN_NAMESPACE( classad )


// forward declarations
class ExprTree;
class ClassAd;
class MatchClassAd;

class EvalState {
    public:
        EvalState( );
        ~EvalState( );

        void SetRootScope( );
        void SetScopes( const ClassAd* );

        int depth_remaining; // max recursion depth - current depth

        const ClassAd *rootAd;
        const ClassAd *curAd;

        bool        flattenAndInline;   // NAC

        // Cache_to_free are the things in the cache that must be
        // freed when this gets deleted. The problem is that we put
        // two kinds of things into the cache: some that must be
        // freed, and some that must not be freed. We keep track of
        // the ones that must be freed separately.  Memory managment
        // is a pain! We should all use languages that do memory
        // management for you.
        //EvalCache   cache_to_delete; 
};

class ExprTree 
{
    public:
        enum NodeKind {
            LITERAL_NODE,
            ATTRREF_NODE,
            OP_NODE,
            FN_CALL_NODE,
            CLASSAD_NODE,
            EXPR_LIST_NODE
        };

        virtual ~ExprTree ();

        void SetParentScope( const ClassAd* p );

        const ClassAd *GetParentScope( ) const { return( parentScope ); }

        virtual ExprTree *Copy( ) const = 0;

        NodeKind GetKind (void) const { return nodeKind; }

        void Puke( ) const;

        bool Evaluate( EvalState &state, Value &val ) const; 
        
        bool Evaluate( Value& v ) const;

        virtual bool SameAs(const ExprTree *tree) const = 0;

    protected:
        ExprTree ();

        void CopyFrom(const ExprTree &literal);

        bool Evaluate( Value& v, ExprTree*& t ) const;
        bool Flatten( Value& val, ExprTree*& tree) const;

        bool Flatten( EvalState&, Value&, ExprTree*&, int* = NULL ) const;
        bool Evaluate( EvalState &, Value &, ExprTree *& ) const;

        const ClassAd   *parentScope;
        NodeKind        nodeKind;

        enum {
            EVAL_FAIL,
            EVAL_OK,
            EVAL_UNDEF,
            PROP_UNDEF,
            EVAL_ERROR,
            PROP_ERROR
        };


    private:
        friend class Operation;
        friend class AttributeReference;
        friend class FunctionCall;
        friend class FunctionTable;
        friend class ExprList;
        friend class ExprListIterator;
        friend class ClassAd; 

        ExprTree(const ExprTree &tree);
        ExprTree &operator=(const ExprTree &literal);

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

        friend bool operator==(const ExprTree &tree1, const ExprTree &tree2);
};

std::ostream& operator<<(std::ostream &os, const ExprTree &expr);

END_NAMESPACE // classad

#include "classad/literals.h"
#include "classad/attrrefs.h"
#include "classad/operators.h"
#include "classad/exprList.h"
#include "classad/classad.h"
#include "classad/fnCall.h"

#endif//__CLASSAD_EXPR_TREE_H__