Expressions.h

Go to the documentation of this file.

//
// Namespace Expressions
//   This namespace contains the representations for all OPAL expressions
//   (scalar and array). It also defines the entire user interface for
//   the expression parser. All classes derived from these classes are
//   declared in this same namespace in the module "Expressions".
//
//   The expression parser is a recursive-descent parser.  When a parse
//   routine recognizes an expression, it returns its internal represenation
//   and skips the corresponding input tokens.  In case of error, a
//   ParseError exception is thrown.
//
// Template class: Expression::Scalar<T>
//   This abstract base class defines the interface for OPAL scalar
//   expressions whose values have type T.
//
// Template class: Expression::Array<T>
//   This abstract base class defines the interface for OPAL array
//   expressions whose components have type T.
//
// Template class: Expression::PtrToScalar<T>
//   This class implements a pointer which owns a scalar expression
//   of type Expression::Scalar<T>.
//
// Template class: Expression::PtrToArray<T>
//   This class implements a pointer which owns an array expression
//   of type Expression::Array<T>.
//
// Template class: Expression::ArrayOfPtrs<T>
//   This class implements an array of pointers, each of which owns
//   an expression of type Expression::Scalar<T>.
//
// Declared functions:
//   A collection of functions implementing a recursive descent parser.
//
//
// Copyright (c) 2008-2020
// Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved.
//
// OPAL is licensed under GNU GPL version 3.
//
 
#ifndef OPAL_Expressions_HH
#define OPAL_Expressions_HH 1
 
#include "MemoryManagement/OwnPtr.h"
#include "Parser/Token.h"
#include <list>
#include <iosfwd>
#include <string>
#include <vector>
 
class PlaceRep;
class RangeRep;
class SFunction;
class Statement;
class Table;
class TableRowRep;
 
// ========================================================================
 
namespace Expressions {
 
 
    // Template class Expression::Scalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T> class Scalar {
 
    public:
 
        Scalar();
        Scalar(const Scalar &);
        virtual ~Scalar();
 
        //  Deep copy of the expression.
        virtual Scalar<T> *clone() const = 0;
 
        //  Recursively evaluate the expression and return the result.
        //  Any non-deferred values are cached.
        virtual T evaluate() const = 0;
 
        //  Default action assumes non-constant.
        virtual bool isConstant() const;
 
        //  Print the expression on the specified stream.
        //  The [b]precedence[/b] parameter controls printing of parentheses.
        virtual void print(std::ostream &, int precedence = 99) const = 0;
 
    private:
 
        // Not implemented.
        void operator=(const Scalar &);
    };
 
 
    // Template class Expression::PtrToScalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T> class PtrToScalar:
        public OwnPtr<Scalar<T> > {
 
    public:
 
        PtrToScalar(Scalar<T> *rhs);
 
        PtrToScalar();
        PtrToScalar(const PtrToScalar &rhs);
        ~PtrToScalar();
        PtrToScalar& operator=(const PtrToScalar&) = default;
    };
 
 
    // Template class Expression::ArrayOfPtrs<T>.
    // ------------------------------------------------------------------------
 
    template <class T> class ArrayOfPtrs: public std::vector<PtrToScalar<T> > {
 
    public:
 
        ArrayOfPtrs();
        ArrayOfPtrs(int);
        ArrayOfPtrs(const std::vector<PtrToScalar<T> > &rhs);
        ~ArrayOfPtrs();
    };
 
 
    // Template class Expression::Array<T>.
    // ----------------------------------------------------------------------
 
    template <class T> class OArray {
 
    public:
 
        OArray();
        OArray(const OArray &);
        virtual ~OArray();
 
        //  Deep copy.
        virtual OArray<T> *clone() const = 0;
 
        //  Recursively evaluate the expression and return the result.
        //  Any non-deferred expression is cached.
        virtual std::vector<T> evaluate() const = 0;
 
        //  Default action assumes non-constant.
        virtual bool isConstant() const;
 
        //  Print the expression on the specified stream.
        //  The [b]precedence[/b] parameter controls printing of parentheses.
        virtual void print(std::ostream &, int precedence = 99) const = 0;
 
    private:
 
        // Not implemented.
        void operator=(const OArray &);
    };
 
 
    // Template class Expression::PtrToArray<T>.
    // ----------------------------------------------------------------------
 
    template <class T> class PtrToArray:
        public OwnPtr<OArray<T> > {
 
    public:
 
        PtrToArray(OArray<T> *rhs);
 
        PtrToArray();
        PtrToArray(const PtrToArray &rhs);
        ~PtrToArray();
        PtrToArray& operator=(const PtrToArray<T>&) = default;
    };
 
 
    // ----------------------------------------------------------------------
    // SCALAR EXPRESSION PARSERS.
 
    extern PtrToScalar<bool> parseBool(Statement &);
 
    extern PtrToScalar<double> parseReal(Statement &);
 
    extern double parseRealConst(Statement &);
 
    //  When no string is seen, a ParseError is thrown with the message
    //  given as the second argument.
    extern std::string parseString(Statement &, const char msg[]);
    extern std::string parseStringValue(Statement &, const char msg[]);
 
    // ARRAY EXPRESSION PARSERS.
 
    extern PtrToArray<bool> parseBoolArray(Statement &);
 
    extern PtrToArray<double> parseRealArray(Statement &);
 
    extern PtrToArray<double> parseRealConstArray(Statement &);
 
    extern std::vector<std::string> parseStringArray(Statement &);
 
 
    // SPECIAL VALUE PARSERS.
 
    extern void parseDelimiter(Statement &stat, char delim);
 
    extern void parseDelimiter(Statement &stat, const char delim[2]);
 
    extern PlaceRep parsePlace(Statement &);
 
    extern RangeRep parseRange(Statement &);
 
    // Forward declaration.
    template <class T> class SRefAttr;
 
    extern SRefAttr<double> *parseReference(Statement &);
 
    extern TableRowRep parseTableRow(Statement &);
 
    extern std::list<Token> parseTokenList(Statement &);
 
    extern std::vector<std::list<Token> > parseTokenListArray(Statement &);
 
 
    // SPECIAL PARSER.
 
    extern PtrToScalar<double> parseTableExpression(Statement &, const Table *);
 
 
    // Implementation of class Expression::Scalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T> inline
    Scalar<T>::Scalar()
    {}
 
 
    template <class T> inline
    Scalar<T>::Scalar(const Scalar<T> &)
    {}
 
 
    template <class T> inline
    Scalar<T>::~Scalar()
    {}
 
 
    template <class T> inline
    bool Scalar<T>::isConstant() const {
        return false;
    }
 
 
    // Implementation of class Expression::OArray<T>.
    // ----------------------------------------------------------------------
 
    template <class T> inline
    OArray<T>::OArray()
    {}
 
 
    template <class T> inline
    OArray<T>::OArray(const OArray<T> &)
    {}
 
 
    template <class T> inline
    OArray<T>::~OArray()
    {}
 
 
    template <class T> inline
    bool OArray<T>::isConstant() const {
        return false;
    }
 
 
    // Implementation of class Expression::PtrToScalar<T>.
    // ----------------------------------------------------------------------
 
 
    template <class T> inline
    PtrToScalar<T>::PtrToScalar():
        OwnPtr<Scalar<T> >()
    {}
 
 
    template <class T> inline
    PtrToScalar<T>::PtrToScalar(const PtrToScalar &rhs):
        OwnPtr<Scalar<T> >(rhs)
    {}
 
 
    template <class T> inline
    PtrToScalar<T>::PtrToScalar(Scalar<T> *rhs):
        OwnPtr<Scalar<T> >(rhs)
    {}
 
 
    template <class T> inline
    PtrToScalar<T>::~PtrToScalar()
    {}
 
 
    // Implementation of class Expression::ArrayOfPtrs<T>.
    // ----------------------------------------------------------------------
 
    template <class T> inline
    ArrayOfPtrs<T>::ArrayOfPtrs():
        std::vector<PtrToScalar<T> >()
    {}
 
 
    template <class T> inline
    ArrayOfPtrs<T>::ArrayOfPtrs(int n):
        std::vector<PtrToScalar<T> >(n, PtrToScalar<T>())
    {}
 
 
    template <class T> inline
    ArrayOfPtrs<T>::ArrayOfPtrs(const std::vector<PtrToScalar<T> > &rhs):
        std::vector<PtrToScalar<T> >(rhs)
    {}
 
 
    template <class T> inline
    ArrayOfPtrs<T>::~ArrayOfPtrs()
    {}
 
 
    // Implementation of class Expression::PtrToArray<T>.
    // ----------------------------------------------------------------------
 
 
    template <class T> inline
    PtrToArray<T>::PtrToArray():
        OwnPtr<OArray<T> >()
    {}
 
 
    template <class T> inline
    PtrToArray<T>::PtrToArray(const PtrToArray &rhs):
        OwnPtr<OArray<T> >(rhs)
    {}
 
 
    template <class T> inline
    PtrToArray<T>::PtrToArray(OArray<T> *rhs):
        OwnPtr<OArray<T> >(rhs)
    {}
 
 
    template <class T> inline
    PtrToArray<T>::~PtrToArray()
    {}
 
 
    // End of namespace Expressions.
    // ======================================================================
};
 
#endif // OPAL_Expressions_HH