Expressions.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Expressions.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.2.4.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Namespace Expressions:
//   This namespace contains the attribute parsers for OPAL:
//   a collection of functions.
//
// ------------------------------------------------------------------------
//
// $Date: 2002/12/09 15:06:08 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------
 
#include "AbstractObjects/Expressions.h"
#include <algorithm>
#include <cerrno>
#include <cmath>
#include <list>
#include <sstream>
#include <vector>
#include "AbstractObjects/Attribute.h"
#include "AbstractObjects/Object.h"
#include "AbstractObjects/OpalData.h"
#include "AbstractObjects/PlaceRep.h"
#include "AbstractObjects/RangeRep.h"
#include "AbstractObjects/Table.h"
#include "AbstractObjects/TableRowRep.h"
#include "PartBunch/PartBunch.h"
#include "Expressions/ABinary.h"
#include "Expressions/AColumn.h"
#include "Expressions/AList.h"
#include "Expressions/ARefExpr.h"
#include "Expressions/ARow.h"
#include "Expressions/ASUnary.h"
#include "Expressions/ATable.h"
#include "Expressions/AUnary.h"
#include "Expressions/Indexer.h"
#include "Expressions/SBinary.h"
#include "Expressions/SCell.h"
#include "Expressions/SConstant.h"
#include "Expressions/SFunction.h"
#include "Expressions/SHash.h"
#include "Expressions/SNull.h"
#include "Expressions/SRefAttr.h"
#include "Expressions/SRefExpr.h"
#include "Expressions/SUnary.h"
#include "Expressions/TFind.h"
#include "Expressions/TFunction0.h"
#include "Expressions/TFunction1.h"
#include "Expressions/TFunction2.h"
#include "OpalParser/Statement.h"
#include "Utilities/OpalException.h"
#include "Utilities/Options.h"
#include "Utilities/ParseError.h"
#include "ValueDefinitions/BoolConstant.h"
#include "ValueDefinitions/StringConstant.h"
 
// Namespace Expressions
// ------------------------------------------------------------------------
 
namespace Expressions {
 
    // Boolean operators.
    // ----------------------------------------------------------------------
 
    bool Or(bool a, bool b) {
        return a || b;
    }
    static const TFunction2<bool, bool> logOr = {"||", 1, Or};
 
    bool And(bool a, bool b) {
        return a && b;
    }
    static const TFunction2<bool, bool> logAnd = {"&&", 2, And};
 
    bool Le(double a, double b) {
        return a <= b;
    }
    static const TFunction2<bool, double> lessEqual = {"<=", 3, Le};
 
    bool Lt(double a, double b) {
        return a < b;
    }
    static const TFunction2<bool, double> less = {"<", 3, Lt};
 
    bool Ge(double a, double b) {
        return a >= b;
    }
    static const TFunction2<bool, double> greaterEqual = {">=", 3, Ge};
 
    bool Gt(double a, double b) {
        return a > b;
    }
    static const TFunction2<bool, double> greater = {">", 3, Gt};
 
    bool Eq(double a, double b) {
        return a == b;
    }
    static const TFunction2<bool, double> equal = {"==", 3, Eq};
 
    bool Ne(double a, double b) {
        return a != b;
    }
    static const TFunction2<bool, double> notEqual = {"!=", 3, Ne};
 
    // Real operators with one or two operands.
    // ----------------------------------------------------------------------
 
    double Neg(double a) {
        return -a;
    }
 
    static const TFunction1<double, double> negate = {"-", 5, Neg};
 
    double Sign(double a) {
        return (a > 0.) ? 1. : (a < 0.) ? -1. : 0.;
    }
 
    double Tgauss(double a) {
        double x, y;
        do {
            Options::rangen.gauss(x, y);
        } while (std::abs(x) > a);
        return x;
    }
 
    double Add(double a, double b) {
        return a + b;
    }
 
    static const TFunction2<double, double> plus = {"+", 4, Add};
 
    double Sub(double a, double b) {
        return a - b;
    }
 
    static const TFunction2<double, double> minus = {"-", 4, Sub};
 
    double Mpy(double a, double b) {
        return a * b;
    }
 
    static TFunction2<double, double> times = {"*", 5, Mpy};
 
    double Div(double a, double b) {
        if (b == 0.0) {
            errno = EDOM;
            return 1.0;
        } else {
            return a / b;
        }
    }
 
    static TFunction2<double, double> divide = {"/", 5, Div};
 
    // Real functions without arguments.
    // ----------------------------------------------------------------------
 
    double getEkin() {
        PartBunch_t* p = OpalData::getInstance()->getPartBunch();
 
        if (p)
            std::cout << "PartBuch valid" << std::endl;
        else
            std::cout << "PartBuch not valid" << std::endl;
 
        if (p)
            return 0.0;
        // return p->get_meanKineticEnergy();
        else
            return -1.0;
    }
 
    double ranf() {
        return Options::rangen.uniform();
    }
 
    double gauss() {
        double x, y;
        Options::rangen.gauss(x, y);
        return x;
    }
 
    static TFunction0<double> table0[] = {
        {"GETEKIN", -2, getEkin},
        {"RANF", -2, ranf},
        {"GAUSS", -2, gauss},
        {"SI", -2, SFunction::arcIn},
        {"SC", -2, SFunction::arcCtr},
        {"SO", -2, SFunction::arcOut},
        {0, -1, 0}};
 
    // Real functions with two arguments.
    // ----------------------------------------------------------------------
 
    static const TFunction1<double, double> table1[] = {
        {"TRUNC", -1, std::trunc}, {"ROUND", -1, std::round}, {"FLOOR", -1, std::floor},
        {"CEIL", -1, std::ceil},   {"SIGN", -1, Sign},        {"SQRT", -1, std::sqrt},
        {"LOG", -1, std::log},     {"EXP", -1, std::exp},     {"SIN", -1, std::sin},
        {"COS", -1, std::cos},     {"ABS", -1, std::abs},     {"TAN", -1, std::tan},
        {"ASIN", -1, std::asin},   {"ACOS", -1, std::acos},   {"ATAN", -1, std::atan},
        {"TGAUSS", -2, Tgauss},    {"ERF", -1, std::erf},     {0, -1, 0}};
 
    // Real functions with two arguments.
    // ----------------------------------------------------------------------
 
    double Max(double a, double b) {
        return std::max(a, b);
    }
 
    double Min(double a, double b) {
        return std::min(a, b);
    }
 
    double Mod(double a, double b) {
        if (b <= 0.0)
            errno = EDOM;
        return fmod(a, b);
    }
 
    static TFunction2<double, double> power = {"^", 6, pow};
 
    static const TFunction2<double, double> table2[] = {{"ATAN2", -1, atan2}, {"MAX", -1, Max},
                                                        {"MIN", -1, Min},     {"MOD", -1, Mod},
                                                        {"POW", -2, pow},     {0, -1, 0}};
 
    // Function of arrays giving a real result.
    // ----------------------------------------------------------------------
 
    double Mina(const std::vector<double>& array) {
        if (array.size()) {
            double result = array[0];
            for (std::vector<double>::size_type i = 1; i < array.size(); ++i) {
                result = Min(array[i], result);
            }
            return result;
        } else if (Options::warn) {
            std::cerr << "\n### Warning ### \"VMIN\" function of empty array.\n" << std::endl;
        }
        return 0.0;
    }
 
    double Maxa(const std::vector<double>& array) {
        if (array.size()) {
            double result = array[0];
            for (std::vector<double>::size_type i = 1; i < array.size(); ++i) {
                result = std::max(array[i], result);
            }
            return result;
        } else if (Options::warn) {
            std::cerr << "\n### Warning ### \"VMAX\" function of empty array.\n" << std::endl;
        }
        return 0.0;
    }
 
    double Rmsa(const std::vector<double>& array) {
        if (array.size()) {
            double result = 0.0;
            for (std::vector<double>::size_type i = 0; i < array.size(); ++i) {
                result += array[i] * array[i];
            }
            return sqrt(result / double(array.size()));
        } else if (Options::warn) {
            std::cerr << "\n### Warning ### \"VRMS\" function of empty array.\n" << std::endl;
        }
        return 0.0;
    }
 
    double AbsMax(const std::vector<double>& array) {
        if (array.size()) {
            double result = std::abs(array[0]);
            for (std::vector<double>::size_type i = 1; i < array.size(); ++i) {
                result = std::max(std::abs(array[i]), result);
            }
            return result;
        } else if (Options::warn) {
            std::cerr << "\n### Warning ### \"VABSMAX\" function of empty array.\n" << std::endl;
        }
        return 0.0;
    }
 
    typedef TFunction1<double, const std::vector<double>&> ArrayFun;
    static const ArrayFun tablea[] = {
        {"VMIN", -1, Mina},
        {"VMAX", -1, Maxa},
        {"VRMS", -1, Rmsa},
        {"VABSMAX", -1, AbsMax},
        {0, -1, 0}};
 
    // Internal variables.
    const Table* currentTable = 0;
    OwnPtr<ATable> currentArray;
 
    // FORWARD DECLARATIONS FOR LOCAL FUNCTIONS.
    // ------------------------------------------------------------------------
 
    // Parse an "&&" expression.
    PtrToScalar<bool> parseAnd(Statement& stat);
 
    // Parse an array factor.
    PtrToArray<double> parseArrayFactor(Statement& stat);
 
    // Parse an array primary.
    PtrToArray<double> parseArrayPrimary(Statement& stat);
 
    // Parse an array term.
    PtrToArray<double> parseArrayTerm(Statement& stat);
 
    // Parse a token list in brackets (for macro argument and the like).
    // This method also checks the nesting of parentheses.
    void parseBracketList(Statement& stat, char close, std::list<Token>& result);
 
    // Parse a real factor.
    PtrToScalar<double> parseFactor(Statement& stat);
 
    // Parse a real primary expression.
    PtrToScalar<double> parsePrimary(Statement& stat);
 
    // Parse a relational expression.
    PtrToScalar<bool> parseRelation(Statement& stat);
 
    // Parse a real term.
    PtrToScalar<double> parseTerm(Statement& stat);
 
    // Parse a column generator "COLUMN(table,column,range)".
    PtrToArray<double> parseColumnGenerator(Statement& stat);
 
    // Parse a row generator "ROW(table,place,...)".
    PtrToArray<double> parseRowGenerator(Statement& stat);
 
    // Parse a table generator "TABLE(n1:n2:n3,expr)".
    PtrToArray<double> parseTableGenerator(Statement& stat);
 
    // PARSE SCALAR EXPRESSIONS.
    // ------------------------------------------------------------------------
 
    PtrToScalar<bool> parseBool(Statement& stat) {
        PtrToScalar<bool> second;
        PtrToScalar<bool> result = parseAnd(stat);
 
        while (stat.delimiter("||")) {
            second = parseAnd(stat);
            result = SBinary<bool, bool>::make(logOr, result, second);
        }
 
        return result;
    }
 
    PtrToScalar<double> parseReal(Statement& stat) {
        PtrToScalar<double> result;
        PtrToScalar<double> second;
 
        if (stat.delimiter('+')) {
            // Unary plus.
            result = parseTerm(stat);
        } else if (stat.delimiter('-')) {
            // Unary minus.
            result = parseTerm(stat);
            result = SUnary<double, double>::make(negate, result);
        } else {
            result = parseTerm(stat);
        }
 
        while (true) {
            if (stat.delimiter('+')) {
                second = parseTerm(stat);
                result = SBinary<double, double>::make(plus, result, second);
            } else if (stat.delimiter('-')) {
                second = parseTerm(stat);
                result = SBinary<double, double>::make(minus, result, second);
            } else {
                break;
            }
        }
 
        return result;
    }
 
    double parseRealConst(Statement& stat) {
        PtrToScalar<double> expr = parseReal(stat);
        return expr->evaluate();
    }
 
    std::string parseString(Statement& stat, const char msg[]) {
        std::string result = std::string("");
        std::string temp;
        bool isWord = stat.word(temp);
 
        while (isWord || stat.str(temp)) {
            if (isWord && temp == "TO_STRING") {
                parseDelimiter(stat, '(');
                double value = parseRealConst(stat);
                parseDelimiter(stat, ')');
                std::ostringstream os;
                os << value;
                result += os.str();
            } else {
                result += temp;
            }
 
            if (!stat.delimiter('&'))
                break;
            isWord = stat.word(temp);
        }
 
        if (result.empty()) {
            std::string errorMsg(msg);
            errorMsg = stat.str() + "\n" + errorMsg;
            throw ParseError("Expressions::parseString()", errorMsg);
        } else {
            return result;
        }
    }
 
    std::string parseStringValue(Statement& stat, const char msg[]) {
        std::string result;
        std::string temp;
        Object* object     = nullptr;
        bool isWord        = stat.word(temp);
        bool isValidObject = isWord && (object = OpalData::getInstance()->find(temp), object);
        bool isConversion  = isWord && temp == "TO_STRING";
 
        while (stat.str(temp) || isValidObject || isConversion) {
            if (isValidObject) {
                StringConstant* stringConst = dynamic_cast<StringConstant*>(object);
                if (stringConst) {
                    result += stringConst->getString();
                } else {
                    result += temp;
                    break;
                }
            } else if (isConversion) {
                parseDelimiter(stat, '(');
                double value = parseRealConst(stat);
                parseDelimiter(stat, ')');
                std::ostringstream os;
                os << value;
                result += os.str();
            } else {
                result += temp;
            }
 
            if (!stat.delimiter('&')) {
                break;
            }
 
            object        = nullptr;
            isWord        = stat.word(temp);
            isValidObject = isWord && (object = OpalData::getInstance()->find(temp), object);
            isConversion  = isWord && temp == "TO_STRING";
        }
 
        if (result.empty()) {
            std::string errorMsg(msg);
            errorMsg = stat.str() + "\n" + errorMsg;
            throw ParseError("Expressions::parseStringValue()", errorMsg);
        } else {
            return result;
        }
    }
 
    // PARSE ARRAY EXPRESSIONS
    // ------------------------------------------------------------------------
 
    PtrToArray<bool> parseBoolArray(Statement& stat) {
        ArrayOfPtrs<bool> array;
 
        if (stat.delimiter('{')) {
            // List of boolean expressions within braces.
            do {
                array.push_back(parseBool(stat));
            } while (stat.delimiter(','));
 
            parseDelimiter(stat, '}');
        } else {
            // A single boolean expression.
            array.push_back(parseBool(stat));
        }
 
        return new AList<bool>(array);
    }
 
    PtrToArray<double> parseRealArray(Statement& stat) {
        PtrToArray<double> result;
        PtrToArray<double> second;
 
        if (stat.delimiter('+')) {
            // Unary plus.
            result = parseArrayTerm(stat);
        } else if (stat.delimiter('-')) {
            // Unary minus.
            result = parseArrayTerm(stat);
            result = new AUnary<double, double>(negate, result);
        } else {
            result = parseArrayTerm(stat);
        }
 
        while (true) {
            if (stat.delimiter('+')) {
                second = parseArrayTerm(stat);
                result = new ABinary<double, double>(plus, result, second);
            } else if (stat.delimiter('-')) {
                second = parseArrayTerm(stat);
                result = new ABinary<double, double>(minus, result, second);
            } else {
                break;
            }
        }
 
        return result;
    }
 
    PtrToArray<double> parseRealConstArray(Statement& stat) {
        PtrToArray<double> arg    = parseRealArray(stat);
        std::vector<double> value = arg->evaluate();
        ArrayOfPtrs<double> array;
 
        for (ArrayOfPtrs<double>::size_type i = 0; i < value.size(); ++i) {
            array.push_back(new SConstant<double>(value[i]));
        }
 
        return new AList<double>(array);
    }
 
    std::vector<std::string> parseStringArray(Statement& stat) {
        std::vector<std::string> array;
 
        if (stat.delimiter('{')) {
            // List of string values within braces.
            do {
                array.push_back(parseStringValue(stat, "String value expected."));
            } while (stat.delimiter(','));
 
            parseDelimiter(stat, '}');
        } else {
            // A single string value.
            array.push_back(parseStringValue(stat, "String value expected."));
        }
 
        return array;
    }
 
    void parseDelimiter(Statement& stat, char delim) {
        if (!stat.delimiter(delim)) {
            throw ParseError(
                "Expressions::parseDelimiter()",
                std::string("Delimiter '") + delim + "' expected.");
        }
    }
 
    void parseDelimiter(Statement& stat, const char delim[2]) {
        if (!stat.delimiter(delim)) {
            throw ParseError(
                "Expressions::parseDelimiter()",
                std::string("Delimiter '") + delim + "' expected.");
        }
    }
 
    PlaceRep parsePlace(Statement& stat) {
        if (stat.keyword("SELECTED")) {
            return PlaceRep("SELECTED");
        } else {
            PlaceRep pos;
 
            do {
                if (stat.delimiter('#')) {
                    static char msg[] = "Expected 'S' or 'E' after '#'.";
                    if (stat.keyword("S")) {
                        pos.append("#S", 0);
                    } else if (stat.keyword("E")) {
                        pos.append("#E", 0);
                    } else {
                        throw ParseError("Expression::parsePlace()", msg);
                    }
                    break;
                } else {
                    std::string name = parseString(stat, "Expected <name> or '#'.");
                    int occurrence   = 1;
                    if (stat.delimiter('[')) {
                        occurrence = int(std::round(parseRealConst(stat)));
                        parseDelimiter(stat, ']');
 
                        if (occurrence <= 0) {
                            throw ParseError(
                                "Expressions::parsePlace()",
                                "Occurrence counter must be positive.");
                        }
                    }
                    pos.append(name, occurrence);
                }
            } while (stat.delimiter("::"));
 
            return pos;
        }
    }
 
    RangeRep parseRange(Statement& stat) {
        if (stat.keyword("FULL")) {
            return RangeRep();
        } else {
            PlaceRep first = parsePlace(stat);
            PlaceRep last  = first;
            if (stat.delimiter('/'))
                last = parsePlace(stat);
            return RangeRep(first, last);
        }
    }
 
    SRefAttr<double>* parseReference(Statement& stat) {
        std::string objName = parseString(stat, "Object name expected.");
 
        // Test for attribute name.
        std::string attrName;
 
        if (stat.delimiter("->")) {
            // Reference to object attribute.
            attrName = parseString(stat, "Attribute name expected.");
        }
 
        // Parse an index, if present.
        int index = 0;
 
        if (stat.delimiter('[')) {
            index = int(std::round(parseRealConst(stat)));
            parseDelimiter(stat, ']');
 
            if (index <= 0) {
                throw ParseError("Expressions::parseReference()", "Index must be positive.");
            }
        }
 
        // Build reference and fill in the attribute pointer.
        return new SRefAttr<double>(objName, attrName, index);
    }
 
    TableRowRep parseTableRow(Statement& stat) {
        std::string tabName = parseString(stat, "Table name expected.");
        parseDelimiter(stat, '@');
        return TableRowRep(tabName, parsePlace(stat));
    }
 
    // ANCILLARY FUNCTIONS.
    // ------------------------------------------------------------------------
 
    PtrToScalar<double> parseTableExpression(Statement& stat, const Table* t) {
        currentTable               = t;
        PtrToScalar<double> result = parseReal(stat);
        currentTable               = 0;
        return result;
    }
 
    std::list<Token> parseTokenList(Statement& stat) {
        std::list<Token> result;
 
        while (!stat.atEnd()) {
            stat.mark();
            Token token = stat.getCurrent();
 
            // End of list if one of the following tokens occurs outside
            // of brackets.
            if (token.isDel(',') || token.isDel(';') || token.isDel(')') || token.isDel(']')
                || token.isDel('}')) {
                // Must reread the terminating token.
                stat.restore();
                break;
            }
 
            result.push_back(token);
 
            if (token.isDel('(')) {
                parseBracketList(stat, ')', result);
            } else if (token.isDel('[')) {
                parseBracketList(stat, ']', result);
            } else if (token.isDel('{')) {
                parseBracketList(stat, '}', result);
            }
        }
 
        return result;
    }
 
    std::vector<std::list<Token> > parseTokenListArray(Statement& stat) {
        std::vector<std::list<Token> > array;
 
        if (stat.delimiter('{')) {
            // List of token lists within braces.
            do {
                array.push_back(parseTokenList(stat));
            } while (stat.delimiter(','));
 
            parseDelimiter(stat, '}');
        } else {
            // A single token list.
            array.push_back(parseTokenList(stat));
        }
 
        return array;
    }
 
    // LOCAL FUNCTIONS.
    PtrToScalar<bool> parseAnd(Statement& stat) {
        PtrToScalar<bool> result = parseRelation(stat);
        PtrToScalar<bool> second;
 
        while (stat.delimiter("&&")) {
            second = parseRelation(stat);
            result = SBinary<bool, bool>::make(logAnd, result, second);
        }
 
        return result;
    }
 
    PtrToArray<double> parseArrayFactor(Statement& stat) {
        PtrToArray<double> result = parseArrayPrimary(stat);
        PtrToArray<double> second;
 
        if (stat.delimiter('^')) {
            second = parseArrayPrimary(stat);
            result = new ABinary<double, double>(power, result, second);
        }
 
        return result;
    }
 
    PtrToArray<double> parseArrayPrimary(Statement& stat) {
        PtrToArray<double> result;
        double value;
 
        if (stat.delimiter('(')) {
            result = parseRealArray(stat);
            parseDelimiter(stat, ')');
        } else if (stat.delimiter('{')) {
            ArrayOfPtrs<double> array;
            do {
                array.push_back(parseReal(stat));
            } while (stat.delimiter(','));
            parseDelimiter(stat, '}');
            result = new AList<double>(array);
        } else if (stat.keyword("COLUMN")) {
            result = parseColumnGenerator(stat);
        } else if (stat.keyword("ROW")) {
            result = parseRowGenerator(stat);
        } else if (stat.keyword("TABLE")) {
            result = parseTableGenerator(stat);
        } else if (stat.real(value)) {
            ArrayOfPtrs<double> array;
            array.push_back(new SConstant<double>(value));
            result = new AList<double>(array);
        } else {
            std::string frstName = parseString(stat, "Object name expected.");
            if (stat.delimiter('(')) {
                // Possible function call.
                PtrToArray<double> arg1;
                PtrToArray<double> arg2;
                if (const TFunction2<double, double>* fun = find(table2, frstName)) {
                    arg1 = parseRealArray(stat);
                    parseDelimiter(stat, ',');
                    arg2   = parseRealArray(stat);
                    result = new ABinary<double, double>(*fun, arg1, arg2);
                } else if (const TFunction1<double, double>* fun = find(table1, frstName)) {
                    arg1   = parseRealArray(stat);
                    result = new AUnary<double, double>(*fun, arg1);
                } else if (frstName == "EVAL") {
                    result = parseRealConstArray(stat);
                } else if (const TFunction0<double>* fun = find(table0, frstName)) {
                    ArrayOfPtrs<double> array;
                    array.push_back(SNull<double>::make(*fun));
                    result = new AList<double>(array);
                } else if (const ArrayFun* fun = find(tablea, frstName)) {
                    arg1 = parseRealArray(stat);
                    ArrayOfPtrs<double> array;
                    array.push_back(new ASUnary<double>(*fun, arg1));
                    result = new AList<double>(array);
                } else {
                    throw ParseError(
                        "parseArrayPrimary()", "Invalid array function name \"" + frstName + "\".");
                }
                parseDelimiter(stat, ')');
            } else if (stat.delimiter("->")) {
                std::string scndName = parseString(stat, "Attribute name expected.");
                result               = new ARefExpr<double>(frstName, scndName);
            } else if (stat.delimiter('@')) {
                PlaceRep row = parsePlace(stat);
                // Possible column names.
                if (stat.delimiter("->")) {
                    std::vector<std::string> cols = parseStringArray(stat);
                    result                        = new ARow(frstName, row, cols);
                } else {
                    throw ParseError("Expressions::parseReal()", "Expected a column name.");
                }
            } else {
                result = new ARefExpr<double>(frstName, "");
            }
        }
 
        return result;
    }
 
    PtrToArray<double> parseArrayTerm(Statement& stat) {
        PtrToArray<double> result = parseArrayFactor(stat);
        PtrToArray<double> second;
 
        while (true) {
            if (stat.delimiter('*')) {
                second = parseArrayFactor(stat);
                result = new ABinary<double, double>(times, result, second);
            } else if (stat.delimiter('/')) {
                second = parseArrayFactor(stat);
                result = new ABinary<double, double>(divide, result, second);
            } else {
                break;
            }
        }
 
        return result;
    }
 
    void parseBracketList(Statement& stat, char close, std::list<Token>& result) {
        while (true) {
            if (stat.atEnd() || stat.delimiter(';')) {
                throw ParseError(
                    "Expressions::parseBracketList()",
                    "Parentheses, brackets or braces do not nest.");
            }
 
            Token token = stat.getCurrent();
            result.push_back(token);
 
            if (token.isDel('(')) {
                parseBracketList(stat, ')', result);
            } else if (token.isDel('[')) {
                parseBracketList(stat, ']', result);
            } else if (token.isDel('{')) {
                parseBracketList(stat, '}', result);
            } else if (token.isDel(close)) {
                return;
            }
        }
    }
 
    PtrToScalar<double> parseFactor(Statement& stat) {
        PtrToScalar<double> result = parsePrimary(stat);
        PtrToScalar<double> second;
 
        if (stat.delimiter('^')) {
            second = parsePrimary(stat);
            result = SBinary<double, double>::make(power, result, second);
        }
 
        return result;
    }
 
    PtrToScalar<double> parsePrimary(Statement& stat) {
        PtrToScalar<double> arg1;
        PtrToScalar<double> arg2;
        PtrToScalar<double> result;
        double value;
 
        if (stat.delimiter('(')) {
            // Expression in "(...)".
            result = parseReal(stat);
            parseDelimiter(stat, ')');
        } else if (stat.real(value)) {
            // Litteral constant.
            result = new SConstant<double>(value);
        } else if (currentArray.isValid() && stat.delimiter('#')) {
            // "#" hash expression
            result = new SHash(*currentArray);
        } else {
            // Primary beginning with a name.
            std::string frstName = parseString(stat, "Real primary expected.");
 
            if (stat.delimiter('(')) {
                // Possible function call.
                if (const TFunction2<double, double>* fun = find(table2, frstName)) {
                    arg1 = parseReal(stat);
                    parseDelimiter(stat, ',');
                    arg2   = parseReal(stat);
                    result = SBinary<double, double>::make(*fun, arg1, arg2);
                } else if (const TFunction1<double, double>* fun = find(table1, frstName)) {
                    arg1   = parseReal(stat);
                    result = SUnary<double, double>::make(*fun, arg1);
                } else if (frstName == "EVAL") {
                    result = new SConstant<double>(parseRealConst(stat));
                } else if (const TFunction0<double>* fun = find(table0, frstName)) {
                    result = SNull<double>::make(*fun);
                } else if (const ArrayFun* fun = find(tablea, frstName)) {
                    PtrToArray<double> arg1 = parseRealArray(stat);
                    result                  = new ASUnary<double>(*fun, arg1);
                } else {
                    throw ParseError(
                        "parsePrimary()", "Unknown function name \"" + frstName + "\".");
                }
                parseDelimiter(stat, ')');
            } else if (stat.delimiter("->")) {
                // Possible parameter or object->attribute clause.
                std::string scndName = parseString(stat, "Attribute or element name expected.");
 
                // Possible index.
                if (stat.delimiter('[')) {
                    arg2 = parseReal(stat);
                    parseDelimiter(stat, ']');
                    PtrToArray<double> arg1 = new ARefExpr<double>(frstName, scndName);
                    result                  = new Indexer<double>(arg1, arg2);
                } else {
                    result = new SRefExpr<double>(frstName, scndName);
                }
            } else if (stat.delimiter('@')) {
                PlaceRep row = parsePlace(stat);
                // Possible column name.
                if (stat.delimiter("->")) {
                    std::string col = parseString(stat, "Column name expected.");
                    result          = new SCell(frstName, row, col);
                } else {
                    throw ParseError("Expressions::parseReal()", "Expected a column name.");
                }
            } else {
                // If the name is indexed, the name must be a global vector.
                if (stat.delimiter('[')) {
                    arg2 = parseReal(stat);
                    parseDelimiter(stat, ']');
                    PtrToArray<double> arg1 = new ARefExpr<double>(frstName, "");
                    result                  = new Indexer<double>(arg1, arg2);
                } else if (currentTable) {
                    // Try making a column expression.
                    result = currentTable->makeColumnExpression(frstName);
                    if (!result.isValid()) {
                        // Could not make a column expression from this name.
                        result = new SRefExpr<double>(frstName, "");
                    }
                } else {
                    // Simple name must be a global variable.
                    result = new SRefExpr<double>(frstName, "");
                }
            }
        }
 
        return result;
    }
 
    PtrToScalar<bool> parseRelation(Statement& stat) {
        PtrToScalar<double> first;
        PtrToScalar<double> second;
        PtrToScalar<bool> result;
        bool value;
        std::string name;
 
        if (stat.delimiter('(')) {
            result = parseBool(stat);
            parseDelimiter(stat, ')');
        } else if (stat.boolean(value)) {
            result = new SConstant<bool>(value);
        } else {
            stat.mark();
            BoolConstant* bc = 0;
            if (stat.word(name)
                && (bc = dynamic_cast<BoolConstant*>(OpalData::getInstance()->find(name)))) {
                return new SConstant<bool>(bc->getBool());
            }
 
            stat.restore();
            first                                = parseReal(stat);
            const TFunction2<bool, double>* code = 0;
            if (stat.delimiter('<')) {
                code = &less;
            } else if (stat.delimiter('>')) {
                code = &greater;
            } else if (stat.delimiter(">=")) {
                code = &greaterEqual;
            } else if (stat.delimiter("<=")) {
                code = &lessEqual;
            } else if (stat.delimiter("==")) {
                code = &equal;
            } else if (stat.delimiter("!=")) {
                code = &notEqual;
            } else {
                throw ParseError("parseRelation()", "Invalid boolean expression.");
            }
            second = parseReal(stat);
            result = SBinary<bool, double>::make(*code, first, second);
        }
 
        return result;
    }
 
    PtrToScalar<double> parseTerm(Statement& stat) {
        PtrToScalar<double> result = parseFactor(stat);
        PtrToScalar<double> second;
 
        while (true) {
            if (stat.delimiter('*')) {
                second = parseFactor(stat);
                result = SBinary<double, double>::make(times, result, second);
            } else if (stat.delimiter('/')) {
                second = parseFactor(stat);
                result = SBinary<double, double>::make(divide, result, second);
            } else {
                break;
            }
        }
 
        return result;
    }
 
    PtrToArray<double> parseColumnGenerator(Statement& stat) {
        // COLUMN function builds an array from a table column.
        // format: COLUMN(<table>, <column>) or
        //         COLUMN(<table>, <column>, <range>).
        // The word "COLUMN" has already been seen by the caller.
        parseDelimiter(stat, '(');
        std::string tabName = parseString(stat, "Table name expected.");
 
        // Column name.
        parseDelimiter(stat, ',');
        std::string colName = parseString(stat, "Column name expected.");
 
        // Optional range specification.
        RangeRep range;
        if (stat.delimiter(',')) {
            range = parseRange(stat);
        }
 
        parseDelimiter(stat, ')');
        return new AColumn(tabName, colName, range);
    }
 
    PtrToArray<double> parseRowGenerator(Statement& stat) {
        // ROW function builds an array from a table row.
        // format: ROW(<table>, <place>) or
        //         ROW(<table>, <place>, <columns>).
        // The word "ROW" has already been seen by the caller.
        parseDelimiter(stat, '(');
        std::string tabName = parseString(stat, "Table name expected.");
 
        // Row position.
        parseDelimiter(stat, ',');
        PlaceRep row = parsePlace(stat);
 
        // Optional column specifications.
        std::vector<std::string> columns;
        if (stat.delimiter(',')) {
            columns = parseStringArray(stat);
            parseDelimiter(stat, ')');
        }
 
        return new ARow(tabName, row, columns);
    }
 
    PtrToArray<double> parseTableGenerator(Statement& stat) {
        // TABLE function generates an array from expressions.
        // format: "TABLE(<n>, <real>)" or
        //         "TABLE(<n1>:<n2>, <real>)" or
        //         "TABLE(<n1>:<n2>:<dn>, <real>)".
        // The word "TABLE" has already been read by the caller.
        parseDelimiter(stat, '(');
 
        // Read the array index set.
        int frst = int(std::round(parseRealConst(stat)));
        int last = 1;
        int step = 1;
 
        if (stat.delimiter(',')) {
            last = frst;
            frst = 1;
        } else if (stat.delimiter(':')) {
            last = int(std::round(parseRealConst(stat)));
            if (stat.delimiter(':')) {
                step = int(std::round(parseRealConst(stat)));
            }
            parseDelimiter(stat, ',');
        } else {
            throw ParseError(
                "Expressions::parseTableGenerator()", "Index set incorrect or missing.");
        }
 
        // Check the array index set.
        if (frst <= 0 || last <= 0 || step <= 0) {
            throw ParseError("Expressions::parseTableGenerator()", "Invalid array index set.");
        }
 
        // Construct the expression generator.
        currentArray = new ATable(frst, last, step);
        currentArray->defineExpression(parseReal(stat));
        parseDelimiter(stat, ')');
 
        // The call to release() is required because of type constraints.
        return currentArray.release();
    }
 
}  // namespace Expressions