libstx-exparser/ExpressionParser.h

Go to the documentation of this file.

// $Id: ExpressionParser.h 59 2007-07-17 14:43:23Z tb $

/*
 * STX Expression Parser C++ Framework v0.7
 * Copyright (C) 2007 Timo Bingmann
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef _STX_ExpressionParser_H_
#define _STX_ExpressionParser_H_

#include <string>
#include <vector>
#include <map>
#include <assert.h>
#include <boost/smart_ptr.hpp>
#include "AnyScalar.h"

namespace stx {

class ExpressionParserException : public std::runtime_error
{
public:
    inline ExpressionParserException(const std::string &s) throw()
        : std::runtime_error(s)
    { }
};

class ConversionException : public ExpressionParserException
{
public:
    inline ConversionException(const std::string &s) throw()
        : ExpressionParserException(s)
    { }
};

class ArithmeticException : public ExpressionParserException
{
public:
    inline ArithmeticException(const std::string &s) throw()
        : ExpressionParserException(s)
    { }
};

class BadSyntaxException : public ExpressionParserException
{
public:
    inline BadSyntaxException(const std::string &s) throw()
        : ExpressionParserException(s)
    { }
};

class UnknownSymbolException : public ExpressionParserException
{
public:
    inline UnknownSymbolException(const std::string &s) throw()
        : ExpressionParserException(s)
    { }
};

class BadFunctionCallException : public ExpressionParserException
{
public:
    inline BadFunctionCallException(const std::string &s) throw()
        : ExpressionParserException(s)
    { }
};

class SymbolTable
{
public:
    typedef std::vector<AnyScalar>      paramlist_type;

    virtual ~SymbolTable();

    virtual AnyScalar   lookupVariable(const std::string &varname) const = 0;

    virtual AnyScalar   processFunction(const std::string &funcname,
                                        const paramlist_type &paramlist) const = 0;
};

class EmptySymbolTable : public SymbolTable
{
public:
    typedef std::vector<AnyScalar>      paramlist_type;

    virtual ~EmptySymbolTable();

    virtual AnyScalar   lookupVariable(const std::string &varname) const;

    virtual AnyScalar   processFunction(const std::string &funcname,
                                        const paramlist_type &paramlist) const;
};

class BasicSymbolTable : public SymbolTable
{
public:
    typedef AnyScalar   (*functionptr_type)(const paramlist_type& paramlist);

protected:

    typedef std::map<std::string, AnyScalar>    variablemap_type;

    struct FunctionInfo
    {
        int             arguments;

        functionptr_type func;

        FunctionInfo(int _arguments = 0, functionptr_type _func = NULL)
            : arguments(_arguments), func(_func)
        {
        }
    };

    typedef std::map<std::string, struct FunctionInfo>  functionmap_type;

private:
    variablemap_type    variablemap;

    functionmap_type    functionmap;

protected:
    // *** Lots of Standard Functions

    static AnyScalar    funcPI(const paramlist_type& paramlist);

    static AnyScalar    funcSIN(const paramlist_type& paramlist);

    static AnyScalar    funcCOS(const paramlist_type& paramlist);

    static AnyScalar    funcTAN(const paramlist_type& paramlist);

    static AnyScalar    funcABS(const paramlist_type& paramlist);

    static AnyScalar    funcEXP(const paramlist_type& paramlist);

    static AnyScalar    funcLOGN(const paramlist_type& paramlist);

    static AnyScalar    funcPOW(const paramlist_type& paramlist);

    static AnyScalar    funcSQRT(const paramlist_type& paramlist);

public:
    BasicSymbolTable();

    virtual ~BasicSymbolTable();

    virtual AnyScalar   lookupVariable(const std::string &varname) const;

    virtual AnyScalar   processFunction(const std::string &funcname,
                                        const paramlist_type &paramlist) const;

    void        setVariable(const std::string& varname, const AnyScalar &value);

    void        setFunction(const std::string& funcname, int arguments, functionptr_type funcptr);

    void        clearVariables();

    void        clearFunctions();

    void        addStandardFunctions();
};

class ParseNode
{
protected:
    inline ParseNode()
    { }

    ParseNode(const ParseNode &pn);

    ParseNode& operator=(const ParseNode &pn);
    
public:
    virtual ~ParseNode()
    {
    }

    virtual AnyScalar evaluate(const class SymbolTable &st = BasicSymbolTable()) const = 0;

    virtual bool evaluate_const(AnyScalar *dest) const = 0;

    virtual std::string toString() const = 0;
};

class ParseTree
{
protected:
    boost::shared_ptr<ParseNode>        rootnode;

public:
    ParseTree()
        : rootnode(static_cast<ParseNode*>(NULL))
    {
    }

    ParseTree(ParseNode* pt)
        : rootnode(pt)
    {
    }

    inline bool isEmpty() const
    {
        return (rootnode.get() == NULL);
    }

    AnyScalar   evaluate(const class SymbolTable &st = BasicSymbolTable()) const
    {
        assert(rootnode.get() != NULL);
        return rootnode->evaluate(st);
    }

    std::string toString() const
    {
        assert(rootnode.get() != NULL);
        return rootnode->toString();
    }
};

const ParseTree parseExpression(const std::string &input);

std::string parseExpressionXML(const std::string &input);

class ParseTreeList : public std::vector<ParseTree>
{
protected:
    typedef std::vector<ParseTree>      parent_type;

public:
    std::vector<AnyScalar>      evaluate(const class SymbolTable &st = BasicSymbolTable()) const;

    std::string toString() const;
};

ParseTreeList parseExpressionList(const std::string &input);

} // namespace stx

#endif // _STX_ExpressionParser_H_

---