source.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_SOURCE_H__
#define __CLASSAD_SOURCE_H__

#include <vector>
#include <iosfwd>
#include "classad/lexer.h"

BEGIN_NAMESPACE( classad )

class ClassAd;
class ExprTree;
class ExprList;
class FunctionCall;

class ClassAdParser
{
    public:
        ClassAdParser();

        ~ClassAdParser();

        ClassAd *ParseClassAd(const std::string &buffer, bool full=false);
        ClassAd *ParseClassAd(const std::string &buffer, int &offset);
        ClassAd *ParseClassAd(const char *buffer, bool full=false);
        ClassAd *ParseClassAd(const char *buffer, int &offset);
        ClassAd *ParseClassAd(FILE *file, bool full=false);
        ClassAd *ParseClassAd(std::istream &stream, bool full=false);

        ClassAd *ParseClassAd(LexerSource *lexer_source, bool full=false);

        bool ParseClassAd(const std::string &buffer, ClassAd &ad, bool full=false);
        bool ParseClassAd(const std::string &buffer, ClassAd &classad, int &offset);
        bool ParseClassAd(const char *buffer, ClassAd &classad, bool full=false);
        bool ParseClassAd(const char *buffer, ClassAd &classad, int &offset);
        bool ParseClassAd(FILE *file, ClassAd &classad, bool full=false);
        bool ParseClassAd(std::istream &stream, ClassAd &classad, bool full=false);

        bool ParseClassAd(LexerSource *lexer_source, ClassAd &ad, bool full=false);

        bool ParseExpression( const std::string &buffer, ExprTree*& expr, 
                    bool full=false);

        bool ParseExpression( LexerSource *lexer_source, ExprTree*& expr, 
                    bool full=false);

        ExprTree *ParseExpression( const std::string &buffer, bool full=false);

        ExprTree *ParseExpression( LexerSource *lexer_source, bool full=false);

        ExprTree *ParseNextExpression(void);

        void SetDebug( bool d ) { lexer.SetDebug( d ); }

        Lexer::TokenType PeekToken(void);
        Lexer::TokenType ConsumeToken(void);

    private:
        // lexical analyser for parser
        Lexer   lexer;

        // mutually recursive parsing functions
        bool parseExpression( ExprTree*&, bool=false);
        bool parseClassAd( ClassAd&, bool=false);
        bool parseExprList( ExprList*&, bool=false);
        bool parseLogicalORExpression( ExprTree*& );
        bool parseLogicalANDExpression( ExprTree*& );
        bool parseInclusiveORExpression( ExprTree*& );
        bool parseExclusiveORExpression( ExprTree*& );
        bool parseANDExpression( ExprTree*& );
        bool parseEqualityExpression( ExprTree*& );
        bool parseRelationalExpression( ExprTree*& );
        bool parseShiftExpression( ExprTree*& );
        bool parseAdditiveExpression( ExprTree*& );
        bool parseMultiplicativeExpression( ExprTree*& );
        bool parseUnaryExpression( ExprTree*& );
        bool parsePostfixExpression( ExprTree*& );
        bool parsePrimaryExpression( ExprTree*& );
        bool parseArgumentList( std::vector<ExprTree*>& );

        bool shouldEvaluateAtParseTime(const std::string &functionName,
                std::vector<ExprTree*> &argList);
        ExprTree *evaluateFunction(const std::string &functionName,
                std::vector<ExprTree*> &argList);

};

std::istream & operator>>(std::istream &stream, ClassAd &ad);

END_NAMESPACE // classad

#endif//__CLASSAD_SOURCE_H__