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

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

#if defined (__GNUC__) && (__GNUC__<3)
#include <ostream.h>
#else
#include <ostream>
#endif

BEGIN_NAMESPACE( classad )

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

typedef classad_hash_map< const ExprTree*, Value, ExprHash > EvalCache;

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

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

                EvalCache       cache;
                ClassAd         *rootAd;
                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 "literals.h"
#include "attrrefs.h"
#include "operators.h"
#include "exprList.h"
#include "classad.h"
#include "fnCall.h"

#endif//__EXPR_TREE_H__