palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-07-01 00:28:12 +02:00
Code Issues Projects Releases Wiki Activity

Apply project code style.

Browse source 
--HG--
branch : feature
This commit is contained in:
dismine 2014-04-30 08:32:29 +03:00
parent 0b49785255
commit 2c77a73343
17 changed files with 7033 additions and 6698 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

588
src/libs/qmuparser/qmuparser.cpp
View file

@ -24,322 +24,366 @@
#include <QtMath> #include <QtMath>
#include <QtGlobal> #include <QtGlobal>
//--- Standard includes ------------------------------------------------------------------------
#include <algorithm>
#include <numeric>
using namespace std; using namespace std;
/** \file /**
\brief Implementation of the standard floating point QmuParser. * @file
*/ * @brief Implementation of the standard floating point QmuParser.
*/
/** \brief Namespace for mathematical applications. */ /**
* @brief Namespace for mathematical applications.
*/
namespace qmu namespace qmu
{ {
//--------------------------------------------------------------------------- // Trigonometric function
// Trigonometric function qreal QmuParser::Sinh(qreal v)
qreal QmuParser::Sinh(qreal v) { return sinh(v); } {
qreal QmuParser::Cosh(qreal v) { return cosh(v); } return sinh(v);
qreal QmuParser::Tanh(qreal v) { return tanh(v); } }
qreal QmuParser::ASinh(qreal v) { return log(v + qSqrt(v * v + 1)); }
qreal QmuParser::ACosh(qreal v) { return log(v + qSqrt(v * v - 1)); }
qreal QmuParser::ATanh(qreal v) { return ((qreal)0.5 * log((1 + v) / (1 - v))); }
//--------------------------------------------------------------------------- qreal QmuParser::Cosh(qreal v)
// Logarithm functions {
return cosh(v);
}
// Logarithm base 2 qreal QmuParser::Tanh(qreal v)
qreal QmuParser::Log2(qreal v) {
{ return tanh(v);
#ifdef MUP_MATH_EXCEPTIONS }
if (v<=0)
throw QmuParserError(ecDOMAIN_ERROR, "Log2");
#endif
return log(v)/log((qreal)2); qreal QmuParser::ASinh(qreal v)
} {
return log(v + qSqrt(v * v + 1));
}
// Logarithm base 10 qreal QmuParser::ACosh(qreal v)
qreal QmuParser::Log10(qreal v) {
{ return log(v + qSqrt(v * v - 1));
#ifdef MUP_MATH_EXCEPTIONS }
if (v<=0)
throw QmuParserError(ecDOMAIN_ERROR, "Log10");
#endif
return log10(v); qreal QmuParser::ATanh(qreal v)
} {
return ((qreal)0.5 * log((1 + v) / (1 - v)));
}
//----------------------------------------------------------------------------------------------------------------------
// Logarithm functions
//--------------------------------------------------------------------------- // Logarithm base 2
// misc qreal QmuParser::Log2(qreal v)
qreal QmuParser::Abs(qreal v) { return qAbs(v); } {
qreal QmuParser::Rint(qreal v) { return qFloor(v + (qreal)0.5); } #ifdef MUP_MATH_EXCEPTIONS
qreal QmuParser::Sign(qreal v) { return (qreal)((v<0) ? -1 : (v>0) ? 1 : 0); } if (v<=0)
{
throw QmuParserError(ecDOMAIN_ERROR, "Log2");
}
#endif
return log(v)/log((qreal)2);
}
//--------------------------------------------------------------------------- // Logarithm base 10
/** \brief Callback for the unary minus operator. qreal QmuParser::Log10(qreal v)
\param v The value to negate {
\return -v #ifdef MUP_MATH_EXCEPTIONS
*/ if (v<=0)
qreal QmuParser::UnaryMinus(qreal v) {
{ throw QmuParserError(ecDOMAIN_ERROR, "Log10");
return -v; }
} #endif
return log10(v);
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Callback for adding multiple values. // misc
\param [in] a_afArg Vector with the function arguments qreal QmuParser::Abs(qreal v)
\param [in] a_iArgc The size of a_afArg {
*/ return qAbs(v);
qreal QmuParser::Sum(const qreal *a_afArg, int a_iArgc) }
{
if (!a_iArgc)
throw exception_type("too few arguments for function sum.");
qreal fRes=0; qreal QmuParser::Rint(qreal v)
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i]; {
return fRes; return qFloor(v + (qreal)0.5);
} }
//--------------------------------------------------------------------------- qreal QmuParser::Sign(qreal v)
/** \brief Callback for averaging multiple values. {
\param [in] a_afArg Vector with the function arguments return (qreal)((v<0) ? -1 : (v>0) ? 1 : 0);
\param [in] a_iArgc The size of a_afArg }
*/
qreal QmuParser::Avg(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
throw exception_type("too few arguments for function sum.");
qreal fRes=0; //----------------------------------------------------------------------------------------------------------------------
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i]; /**
return fRes/(qreal)a_iArgc; * @brief Callback for the unary minus operator.
} * @param v The value to negate
* @return -v
*/
qreal QmuParser::UnaryMinus(qreal v)
{
return -v;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for adding multiple values.
* @param [in] a_afArg Vector with the function arguments
* @param [in] a_iArgc The size of a_afArg
*/
qreal QmuParser::Sum(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
{
throw exception_type("too few arguments for function sum.");
}
qreal fRes=0;
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
return fRes;
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Callback for determining the minimum value out of a vector. /**
\param [in] a_afArg Vector with the function arguments * @brief Callback for averaging multiple values.
\param [in] a_iArgc The size of a_afArg * @param [in] a_afArg Vector with the function arguments
*/ * @param [in] a_iArgc The size of a_afArg
*/
qreal QmuParser::Avg(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
{
throw exception_type("too few arguments for function sum.");
}
qreal fRes=0;
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
return fRes/(qreal)a_iArgc;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for determining the minimum value out of a vector.
* @param [in] a_afArg Vector with the function arguments
* @param [in] a_iArgc The size of a_afArg
*/
qreal QmuParser::Min(const qreal *a_afArg, int a_iArgc) qreal QmuParser::Min(const qreal *a_afArg, int a_iArgc)
{ {
if (!a_iArgc) if (!a_iArgc)
{ {
throw exception_type("too few arguments for function min."); throw exception_type("too few arguments for function min.");
} }
qreal fRes=a_afArg[0];
qreal fRes=a_afArg[0]; for (int i=0; i<a_iArgc; ++i)
for (int i=0; i<a_iArgc; ++i) {
{ fRes = qMin(fRes, a_afArg[i]);
fRes = qMin(fRes, a_afArg[i]); }
} return fRes;
return fRes;
} }
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Callback for determining the maximum value out of a vector. /**
\param [in] a_afArg Vector with the function arguments * @brief Callback for determining the maximum value out of a vector.
\param [in] a_iArgc The size of a_afArg * @param [in] a_afArg Vector with the function arguments
*/ * @param [in] a_iArgc The size of a_afArg
*/
qreal QmuParser::Max(const qreal *a_afArg, int a_iArgc) qreal QmuParser::Max(const qreal *a_afArg, int a_iArgc)
{ {
if (!a_iArgc) if (!a_iArgc)
{ {
throw exception_type("too few arguments for function min."); throw exception_type("too few arguments for function min.");
} }
qreal fRes=a_afArg[0];
qreal fRes=a_afArg[0]; for (int i=0; i<a_iArgc; ++i)
for (int i=0; i<a_iArgc; ++i) {
{ fRes = qMax(fRes, a_afArg[i]);
fRes = qMax(fRes, a_afArg[i]); }
} return fRes;
return fRes;
} }
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Default value recognition callback.
* @param [in] a_szExpr Pointer to the expression
* @param [in, out] a_iPos Pointer to an index storing the current position within the expression
* @param [out] a_fVal Pointer where the value should be stored in case one is found.
* @return 1 if a value was found 0 otherwise.
*/
int QmuParser::IsVal(const QString &a_szExpr, int *a_iPos, qreal *a_fVal)
{
qreal fVal(0);
//--------------------------------------------------------------------------- #if defined(_UNICODE)
/** \brief Default value recognition callback. std::wstring a_szExprStd = a_szExpr.toStdWString();
\param [in] a_szExpr Pointer to the expression #else
\param [in, out] a_iPos Pointer to an index storing the current position within the expression std::string a_szExprStd = a_szExpr.toStdString();
\param [out] a_fVal Pointer where the value should be stored in case one is found. #endif
\return 1 if a value was found 0 otherwise. stringstream_type stream(a_szExprStd);
*/ stream.seekg(0); // todo: check if this really is necessary
int QmuParser::IsVal(const QString &a_szExpr, int *a_iPos, qreal *a_fVal) stream.imbue(QmuParser::s_locale);
{ stream >> fVal;
qreal fVal(0); stringstream_type::pos_type iEnd = stream.tellg(); // Position after reading
#if defined(_UNICODE) if (iEnd==(stringstream_type::pos_type)-1)
std::wstring a_szExprStd = a_szExpr.toStdWString(); {
#else return 0;
std::string a_szExprStd = a_szExpr.toStdString(); }
#endif
stringstream_type stream(a_szExprStd);
stream.seekg(0); // todo: check if this really is necessary
stream.imbue(QmuParser::s_locale);
stream >> fVal;
stringstream_type::pos_type iEnd = stream.tellg(); // Position after reading
if (iEnd==(stringstream_type::pos_type)-1) *a_iPos += (int)iEnd;
return 0; *a_fVal = fVal;
return 1;
}
*a_iPos += (int)iEnd; //----------------------------------------------------------------------------------------------------------------------
*a_fVal = fVal; /**
return 1; * @brief Constructor.
} *
* Call QmuParserBase class constructor and trigger Function, Operator and Constant initialization.
*/
QmuParser::QmuParser():QmuParserBase()
{
AddValIdent(IsVal);
InitCharSets();
InitFun();
InitConst();
InitOprt();
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Constructor. /**
* @brief Define the character sets.
* @sa DefineNameChars, DefineOprtChars, DefineInfixOprtChars
*
* This function is used for initializing the default character sets that define
* the characters to be useable in function and variable names and operators.
*/
void QmuParser::InitCharSets()
{
DefineNameChars( "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" );
DefineOprtChars( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_{}" );
DefineInfixOprtChars( "/+-*^?<>=#!$%&|~'_" );
}
Call QmuParserBase class constructor and trigger Function, Operator and Constant initialization. //----------------------------------------------------------------------------------------------------------------------
*/ /**
QmuParser::QmuParser() * @brief Initialize the default functions.
:QmuParserBase() */
{
AddValIdent(IsVal);
InitCharSets();
InitFun();
InitConst();
InitOprt();
}
//---------------------------------------------------------------------------
/** \brief Define the character sets.
\sa DefineNameChars, DefineOprtChars, DefineInfixOprtChars
This function is used for initializing the default character sets that define
the characters to be useable in function and variable names and operators.
*/
void QmuParser::InitCharSets()
{
DefineNameChars( "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" );
DefineOprtChars( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_{}" );
DefineInfixOprtChars( "/+-*^?<>=#!$%&|~'_" );
}
//---------------------------------------------------------------------------
/** \brief Initialize the default functions. */
void QmuParser::InitFun() void QmuParser::InitFun()
{ {
// trigonometric functions // trigonometric functions
DefineFun("sin", qSin); DefineFun("sin", qSin);
DefineFun("cos", qCos); DefineFun("cos", qCos);
DefineFun("tan", qTan); DefineFun("tan", qTan);
// arcus functions // arcus functions
DefineFun("asin", qAsin); DefineFun("asin", qAsin);
DefineFun("acos", qAcos); DefineFun("acos", qAcos);
DefineFun("atan", qAtan); DefineFun("atan", qAtan);
DefineFun("atan2", qAtan2); DefineFun("atan2", qAtan2);
// hyperbolic functions // hyperbolic functions
DefineFun("sinh", Sinh); DefineFun("sinh", Sinh);
DefineFun("cosh", Cosh); DefineFun("cosh", Cosh);
DefineFun("tanh", Tanh); DefineFun("tanh", Tanh);
// arcus hyperbolic functions // arcus hyperbolic functions
DefineFun("asinh", ASinh); DefineFun("asinh", ASinh);
DefineFun("acosh", ACosh); DefineFun("acosh", ACosh);
DefineFun("atanh", ATanh); DefineFun("atanh", ATanh);
// Logarithm functions // Logarithm functions
DefineFun("log2", Log2); DefineFun("log2", Log2);
DefineFun("log10", Log10); DefineFun("log10", Log10);
DefineFun("log", Log10); DefineFun("log", Log10);
DefineFun("ln", qLn); DefineFun("ln", qLn);
// misc // misc
DefineFun("exp", qExp); DefineFun("exp", qExp);
DefineFun("sqrt", qSqrt); DefineFun("sqrt", qSqrt);
DefineFun("sign", Sign); DefineFun("sign", Sign);
DefineFun("rint", Rint); DefineFun("rint", Rint);
DefineFun("abs", Abs); DefineFun("abs", Abs);
// Functions with variable number of arguments // Functions with variable number of arguments
DefineFun("sum", Sum); DefineFun("sum", Sum);
DefineFun("avg", Avg); DefineFun("avg", Avg);
DefineFun("min", Min); DefineFun("min", Min);
DefineFun("max", Max); DefineFun("max", Max);
} }
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Initialize constants. /**
* @brief Initialize constants.
*
* By default the QmuParser recognizes two constants. Pi ("pi") and the eulerian
* number ("_e").
*/
void QmuParser::InitConst()
{
DefineConst("_pi", (qreal)M_PI);
DefineConst("_e", (qreal)M_E);
}
By default the QmuParser recognizes two constants. Pi ("pi") and the eulerian //----------------------------------------------------------------------------------------------------------------------
number ("_e"). /**
*/ * @brief Initialize operators.
void QmuParser::InitConst() *
{ * By default only the unary minus operator is added.
DefineConst("_pi", (qreal)M_PI); */
DefineConst("_e", (qreal)M_E); void QmuParser::InitOprt()
} {
DefineInfixOprt("-", UnaryMinus);
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Initialize operators. void QmuParser::OnDetectVar(string_type * /*pExpr*/, int & /*nStart*/, int & /*nEnd*/)
{
By default only the unary minus operator is added. // this is just sample code to illustrate modifying variable names on the fly.
*/ // I'm not sure anyone really needs such a feature...
void QmuParser::InitOprt() /*
{
DefineInfixOprt("-", UnaryMinus);
}
//---------------------------------------------------------------------------
void QmuParser::OnDetectVar(string_type * /*pExpr*/, int & /*nStart*/, int & /*nEnd*/)
{
// this is just sample code to illustrate modifying variable names on the fly.
// I'm not sure anyone really needs such a feature...
/*
string sVar(pExpr->begin()+nStart, pExpr->begin()+nEnd); string sVar(pExpr->begin()+nStart, pExpr->begin()+nEnd);
string sRepl = std::string("_") + sVar + "_"; string sRepl = std::string("_") + sVar + "_";
int nOrigVarEnd = nEnd; int nOrigVarEnd = nEnd;
cout << "variable detected!\n"; cout << "variable detected!\n";
cout << " Expr: " << *pExpr << "\n"; cout << " Expr: " << *pExpr << "\n";
cout << " Start: " << nStart << "\n"; cout << " Start: " << nStart << "\n";
cout << " End: " << nEnd << "\n"; cout << " End: " << nEnd << "\n";
cout << " Var: \"" << sVar << "\"\n"; cout << " Var: \"" << sVar << "\"\n";
cout << " Repl: \"" << sRepl << "\"\n"; cout << " Repl: \"" << sRepl << "\"\n";
nEnd = nStart + sRepl.length(); nEnd = nStart + sRepl.length();
cout << " End: " << nEnd << "\n"; cout << " End: " << nEnd << "\n";
pExpr->replace(pExpr->begin()+nStart, pExpr->begin()+nOrigVarEnd, sRepl); pExpr->replace(pExpr->begin()+nStart, pExpr->begin()+nOrigVarEnd, sRepl);
cout << " New expr: " << *pExpr << "\n"; cout << " New expr: " << *pExpr << "\n";
*/ */
} }
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Numerically differentiate with regard to a variable. /**
\param [in] a_Var Pointer to the differentiation variable. * @brief Numerically differentiate with regard to a variable.
\param [in] a_fPos Position at which the differentiation should take place. * @param [in] a_Var Pointer to the differentiation variable.
\param [in] a_fEpsilon Epsilon used for the numerical differentiation. * @param [in] a_fPos Position at which the differentiation should take place.
* @param [in] a_fEpsilon Epsilon used for the numerical differentiation.
*
* Numerical differentiation uses a 5 point operator yielding a 4th order
* formula. The default value for epsilon is 0.00074 which is
* numeric_limits<double>::epsilon() ^ (1/5) as suggested in the muQmuParser
* forum:
*
* http://sourceforge.net/forum/forum.php?thread_id=1994611&forum_id=462843
*/
qreal QmuParser::Diff(qreal *a_Var, qreal a_fPos, qreal a_fEpsilon) const
{
qreal fRes(0),
fBuf(*a_Var),
f[4] = {0,0,0,0},
fEpsilon(a_fEpsilon);
Numerical differentiation uses a 5 point operator yielding a 4th order // Backwards compatible calculation of epsilon inc case the user doesnt provide
formula. The default value for epsilon is 0.00074 which is // his own epsilon
numeric_limits<double>::epsilon() ^ (1/5) as suggested in the muQmuParser if (fEpsilon==0)
forum: {
fEpsilon = (a_fPos==0) ? (qreal)1e-10 : (qreal)1e-7 * a_fPos;
}
http://sourceforge.net/forum/forum.php?thread_id=1994611&forum_id=462843 *a_Var = a_fPos+2 * fEpsilon; f[0] = Eval();
*/ *a_Var = a_fPos+1 * fEpsilon; f[1] = Eval();
qreal QmuParser::Diff(qreal *a_Var, *a_Var = a_fPos-1 * fEpsilon; f[2] = Eval();
qreal a_fPos, *a_Var = a_fPos-2 * fEpsilon; f[3] = Eval();
qreal a_fEpsilon) const *a_Var = fBuf; // restore variable
{
qreal fRes(0),
fBuf(*a_Var),
f[4] = {0,0,0,0},
fEpsilon(a_fEpsilon);
// Backwards compatible calculation of epsilon inc case the user doesnt provide fRes = (-f[0] + 8*f[1] - 8*f[2] + f[3]) / (12*fEpsilon);
// his own epsilon return fRes;
if (fEpsilon==0) }
fEpsilon = (a_fPos==0) ? (qreal)1e-10 : (qreal)1e-7 * a_fPos;
*a_Var = a_fPos+2 * fEpsilon; f[0] = Eval();
*a_Var = a_fPos+1 * fEpsilon; f[1] = Eval();
*a_Var = a_fPos-1 * fEpsilon; f[2] = Eval();
*a_Var = a_fPos-2 * fEpsilon; f[3] = Eval();
*a_Var = fBuf; // restore variable
fRes = (-f[0] + 8*f[1] - 8*f[2] + f[3]) / (12*fEpsilon);
return fRes;
}
} // namespace qmu } // namespace qmu

108
src/libs/qmuparser/qmuparser.h
View file

@ -24,67 +24,63 @@
#define QMUPARSER_H #define QMUPARSER_H
#include "qmuparser_global.h" #include "qmuparser_global.h"
//--- Parser includes --------------------------------------------------------------------------
#include "qmuparserbase.h" #include "qmuparserbase.h"
/** \file /**
\brief Definition of the standard floating point parser. * @file
*/ * @brief Definition of the standard floating point parser.
*/
namespace qmu namespace qmu
{ {
/** \brief Mathematical expressions parser. /** @brief Mathematical expressions parser.
*
Standard implementation of the mathematical expressions parser. * Standard implementation of the mathematical expressions parser.
Can be used as a reference implementation for subclassing the parser. * Can be used as a reference implementation for subclassing the parser.
*
<small> * <small>
(C) 2011 Ingo Berg<br> * (C) 2011 Ingo Berg<br>
muparser(at)gmx.de * muparser(at)gmx.de
</small> * </small>
*/ */
/* final */ class QMUPARSERSHARED_EXPORT QmuParser : public QmuParserBase /* final */ class QMUPARSERSHARED_EXPORT QmuParser : public QmuParserBase
{ {
public:
public: QmuParser();
QmuParser(); virtual void InitCharSets();
virtual void InitCharSets(); virtual void InitFun();
virtual void InitFun(); virtual void InitConst();
virtual void InitConst(); virtual void InitOprt();
virtual void InitOprt(); virtual void OnDetectVar(string_type *pExpr, int &nStart, int &nEnd);
virtual void OnDetectVar(string_type *pExpr, int &nStart, int &nEnd); qreal Diff(qreal *a_Var, qreal a_fPos, qreal a_fEpsilon = 0) const;
protected:
qreal Diff(qreal *a_Var, qreal a_fPos, qreal a_fEpsilon = 0) const; static int IsVal(const QString &a_szExpr, int *a_iPos, qreal *a_fVal);
protected: // Trigonometric functions
// Trigonometric functions static qreal Tan2(qreal, qreal);
static qreal Tan2(qreal, qreal); // hyperbolic functions
// hyperbolic functions static qreal Sinh(qreal);
static qreal Sinh(qreal); static qreal Cosh(qreal);
static qreal Cosh(qreal); static qreal Tanh(qreal);
static qreal Tanh(qreal); // arcus hyperbolic functions
// arcus hyperbolic functions static qreal ASinh(qreal);
static qreal ASinh(qreal); static qreal ACosh(qreal);
static qreal ACosh(qreal); static qreal ATanh(qreal);
static qreal ATanh(qreal); // Logarithm functions
// Logarithm functions static qreal Log2(qreal); // Logarithm Base 2
static qreal Log2(qreal); // Logarithm Base 2 static qreal Log10(qreal); // Logarithm Base 10
static qreal Log10(qreal); // Logarithm Base 10 // misc
// misc static qreal Abs(qreal);
static qreal Abs(qreal); static qreal Rint(qreal);
static qreal Rint(qreal); static qreal Sign(qreal);
static qreal Sign(qreal); // Prefix operators
// Prefix operators // !!! Unary Minus is a MUST if you want to use negative signs !!!
// !!! Unary Minus is a MUST if you want to use negative signs !!! static qreal UnaryMinus(qreal);
static qreal UnaryMinus(qreal); // Functions with variable number of arguments
// Functions with variable number of arguments static qreal Sum(const qreal*, int); // sum
static qreal Sum(const qreal*, int); // sum static qreal Avg(const qreal*, int); // mean value
static qreal Avg(const qreal*, int); // mean value static qreal Min(const qreal*, int); // minimum
static qreal Min(const qreal*, int); // minimum static qreal Max(const qreal*, int); // maximum
static qreal Max(const qreal*, int); // maximum };
static int IsVal(const QString &a_szExpr, int *a_iPos, qreal *a_fVal);
};
} // namespace qmu } // namespace qmu

3576
src/libs/qmuparser/qmuparserbase.cpp
View file

File diff suppressed because it is too large Load diff

460
src/libs/qmuparser/qmuparserbase.h
View file

@ -23,18 +23,10 @@
#ifndef QMUQPARSERBASE_H #ifndef QMUQPARSERBASE_H
#define QMUQPARSERBASE_H #define QMUQPARSERBASE_H
//--- Standard includes ------------------------------------------------------------------------
#include <cmath>
#include <string>
#include <iostream>
#include <map>
#include <memory>
#include <locale>
#include <QStack> #include <QStack>
#include <QString> #include <QString>
#include <QStringList> #include <QStringList>
//--- Parser includes --------------------------------------------------------------------------
#include "qmuparserdef.h" #include "qmuparserdef.h"
#include "qmuparsertokenreader.h" #include "qmuparsertokenreader.h"
#include "qmuparserbytecode.h" #include "qmuparserbytecode.h"
@ -43,261 +35,227 @@
namespace qmu namespace qmu
{ {
/** \file /**
\brief This file contains the class definition of the qmuparser engine. * @file
*/ * @brief This file contains the class definition of the qmuparser engine.
*/
//-------------------------------------------------------------------------------------------------- /**
/** \brief Mathematical expressions parser (base parser engine). * @brief Mathematical expressions parser (base parser engine).
\author (C) 2013 Ingo Berg * @author (C) 2013 Ingo Berg
*
This is the implementation of a bytecode based mathematical expressions parser. * This is the implementation of a bytecode based mathematical expressions parser.
The formula will be parsed from string and converted into a bytecode. * The formula will be parsed from string and converted into a bytecode.
Future calculations will be done with the bytecode instead the formula string * Future calculations will be done with the bytecode instead the formula string
resulting in a significant performance increase. * resulting in a significant performance increase.
Complementary to a set of internally implemented functions the parser is able to handle * Complementary to a set of internally implemented functions the parser is able to handle
user defined functions and variables. * user defined functions and variables.
*/ */
class QmuParserBase class QmuParserBase
{
friend class QmuParserTokenReader;
private:
/** \brief Typedef for the parse functions.
The parse function do the actual work. The parser exchanges
the function pointer to the parser function depending on
which state it is in. (i.e. bytecode parser vs. string parser)
*/
typedef qreal (QmuParserBase::*ParseFunction)() const;
/** \brief Type used for storing an array of values. */
typedef QVector<qreal> valbuf_type;
/** \brief Type for a vector of strings. */
typedef QVector<QString> stringbuf_type;
/** \brief Typedef for the token reader. */
typedef QmuParserTokenReader token_reader_type;
/** \brief Type used for parser tokens. */
typedef QmuParserToken<qreal, QString> token_type;
/** \brief Maximum number of threads spawned by OpenMP when using the bulk mode. */
static const int s_MaxNumOpenMPThreads = 4;
public:
/** \brief Type of the error class.
Included for backwards compatibility.
*/
typedef QmuParserError exception_type;
static void EnableDebugDump(bool bDumpCmd, bool bDumpStack);
QmuParserBase();
QmuParserBase(const QmuParserBase &a_Parser);
QmuParserBase& operator=(const QmuParserBase &a_Parser);
virtual ~QmuParserBase();
qreal Eval() const;
qreal* Eval(int &nStackSize) const;
void Eval(qreal *results, int nBulkSize);
int GetNumResults() const;
void SetExpr(const QString &a_sExpr);
void SetVarFactory(facfun_type a_pFactory, void *pUserData = NULL);
void SetDecSep(char_type cDecSep);
void SetThousandsSep(char_type cThousandsSep = 0);
void ResetLocale();
void EnableOptimizer(bool a_bIsOn=true);
void EnableBuiltInOprt(bool a_bIsOn=true);
bool HasBuiltInOprt() const;
void AddValIdent(identfun_type a_pCallback);
/** \fn void qmu::QmuParserBase::DefineFun(const string_type &a_strName, fun_type0 a_pFun, bool a_bAllowOpt = true)
\brief Define a parser function without arguments.
\param a_strName Name of the function
\param a_pFun Pointer to the callback function
\param a_bAllowOpt A flag indicating this function may be optimized
*/
template<typename T>
void DefineFun(const QString &a_strName, T a_pFun, bool a_bAllowOpt = true)
{
AddCallback( a_strName, QmuParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars() );
}
void DefineOprt(const QString &a_strName,
fun_type2 a_pFun,
unsigned a_iPri=0,
EOprtAssociativity a_eAssociativity = oaLEFT,
bool a_bAllowOpt = false);
void DefineConst(const QString &a_sName, qreal a_fVal);
void DefineStrConst(const QString &a_sName, const QString &a_strVal);
void DefineVar(const QString &a_sName, qreal *a_fVar);
void DefinePostfixOprt(const QString &a_strFun, fun_type1 a_pOprt, bool a_bAllowOpt=true);
void DefineInfixOprt(const QString &a_strName, fun_type1 a_pOprt, int a_iPrec=prINFIX, bool a_bAllowOpt=true);
// Clear user defined variables, constants or functions
void ClearVar();
void ClearFun();
void ClearConst();
void ClearInfixOprt();
void ClearPostfixOprt();
void ClearOprt();
void RemoveVar(const QString &a_strVarName);
const varmap_type& GetUsedVar() const;
const varmap_type& GetVar() const;
const valmap_type& GetConst() const;
const QString &GetExpr() const;
const funmap_type& GetFunDef() const;
string_type GetVersion(EParserVersionInfo eInfo = pviFULL) const;
const QStringList &GetOprtDef() const;
void DefineNameChars(const QString &a_szCharset);
void DefineOprtChars(const QString &a_szCharset);
void DefineInfixOprtChars(const QString &a_szCharset);
const QString& ValidNameChars() const;
const QString &ValidOprtChars() const;
const QString &ValidInfixOprtChars() const;
void SetArgSep(char_type cArgSep);
QChar GetArgSep() const;
void Error(EErrorCodes a_iErrc,
int a_iPos = -1,
const QString &a_strTok = QString() ) const;
protected:
void Init();
virtual void InitCharSets() = 0;
virtual void InitFun() = 0;
virtual void InitConst() = 0;
virtual void InitOprt() = 0;
virtual void OnDetectVar(QString *pExpr, int &nStart, int &nEnd);
static const QStringList c_DefaultOprt;
static std::locale s_locale; ///< The locale used by the parser
static bool g_DbgDumpCmdCode;
static bool g_DbgDumpStack;
/** \brief A facet class used to change decimal and thousands separator. */
template<class TChar>
class change_dec_sep : public std::numpunct<TChar>
{ {
friend class QmuParserTokenReader;
public: public:
/**
* @brief Type of the error class.
*
* Included for backwards compatibility.
*/
typedef QmuParserError exception_type;
explicit change_dec_sep(char_type cDecSep, char_type cThousandsSep = 0, int nGroup = 3) QmuParserBase();
:std::numpunct<TChar>() QmuParserBase(const QmuParserBase &a_Parser);
,m_nGroup(nGroup) QmuParserBase& operator=(const QmuParserBase &a_Parser);
,m_cDecPoint(cDecSep) virtual ~QmuParserBase();
,m_cThousandsSep(cThousandsSep)
{}
static void EnableDebugDump(bool bDumpCmd, bool bDumpStack);
qreal Eval() const;
qreal* Eval(int &nStackSize) const;
void Eval(qreal *results, int nBulkSize);
int GetNumResults() const;
void SetExpr(const QString &a_sExpr);
void SetVarFactory(facfun_type a_pFactory, void *pUserData = NULL);
void SetDecSep(char_type cDecSep);
void SetThousandsSep(char_type cThousandsSep = 0);
void ResetLocale();
void EnableOptimizer(bool a_bIsOn=true);
void EnableBuiltInOprt(bool a_bIsOn=true);
bool HasBuiltInOprt() const;
void AddValIdent(identfun_type a_pCallback);
void DefineOprt(const QString &a_strName, fun_type2 a_pFun, unsigned a_iPri=0,
EOprtAssociativity a_eAssociativity = oaLEFT, bool a_bAllowOpt = false);
void DefineConst(const QString &a_sName, qreal a_fVal);
void DefineStrConst(const QString &a_sName, const QString &a_strVal);
void DefineVar(const QString &a_sName, qreal *a_fVar);
void DefinePostfixOprt(const QString &a_strFun, fun_type1 a_pOprt, bool a_bAllowOpt=true);
void DefineInfixOprt(const QString &a_strName, fun_type1 a_pOprt, int a_iPrec=prINFIX,
bool a_bAllowOpt=true);
// Clear user defined variables, constants or functions
void ClearVar();
void ClearFun();
void ClearConst();
void ClearInfixOprt();
void ClearPostfixOprt();
void ClearOprt();
void RemoveVar(const QString &a_strVarName);
const varmap_type& GetUsedVar() const;
const varmap_type& GetVar() const;
const valmap_type& GetConst() const;
const QString& GetExpr() const;
const funmap_type& GetFunDef() const;
QString GetVersion(EParserVersionInfo eInfo = pviFULL) const;
const QStringList& GetOprtDef() const;
void DefineNameChars(const QString &a_szCharset);
void DefineOprtChars(const QString &a_szCharset);
void DefineInfixOprtChars(const QString &a_szCharset);
const QString& ValidNameChars() const;
const QString& ValidOprtChars() const;
const QString& ValidInfixOprtChars() const;
void SetArgSep(char_type cArgSep);
QChar GetArgSep() const;
void Error(EErrorCodes a_iErrc, int a_iPos = -1, const QString &a_strTok = QString() ) const;
/**
* @fn void qmu::QmuParserBase::DefineFun(const string_type &a_strName, fun_type0 a_pFun,
* bool a_bAllowOpt = true)
* @brief Define a parser function without arguments.
* @param a_strName Name of the function
* @param a_pFun Pointer to the callback function
* @param a_bAllowOpt A flag indicating this function may be optimized
*/
template<typename T>
void DefineFun(const QString &a_strName, T a_pFun, bool a_bAllowOpt = true)
{
AddCallback( a_strName, QmuParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars() );
}
protected: protected:
static const QStringList c_DefaultOprt;
static std::locale s_locale; ///< The locale used by the parser
static bool g_DbgDumpCmdCode;
static bool g_DbgDumpStack;
void Init();
virtual void InitCharSets() = 0;
virtual void InitFun() = 0;
virtual void InitConst() = 0;
virtual void InitOprt() = 0;
virtual void OnDetectVar(QString *pExpr, int &nStart, int &nEnd);
/**
* @brief A facet class used to change decimal and thousands separator.
*/
template<class TChar>
class change_dec_sep : public std::numpunct<TChar>
{
public:
explicit change_dec_sep(char_type cDecSep, char_type cThousandsSep = 0, int nGroup = 3)
:std::numpunct<TChar>(), m_nGroup(nGroup), m_cDecPoint(cDecSep), m_cThousandsSep(cThousandsSep)
{}
protected:
virtual char_type do_decimal_point() const
{
return m_cDecPoint;
}
virtual char_type do_decimal_point() const virtual char_type do_thousands_sep() const
{ {
return m_cDecPoint; return m_cThousandsSep;
} }
virtual char_type do_thousands_sep() const
{
return m_cThousandsSep;
}
virtual std::string do_grouping() const
{
return std::string(1, m_nGroup);
}
virtual std::string do_grouping() const
{
return std::string(1, m_nGroup);
}
private:
int m_nGroup;
char_type m_cDecPoint;
char_type m_cThousandsSep;
};
private: private:
/**
* @brief Typedef for the parse functions.
*
* The parse function do the actual work. The parser exchanges
* the function pointer to the parser function depending on
* which state it is in. (i.e. bytecode parser vs. string parser)
*/
typedef qreal (QmuParserBase::*ParseFunction)() const;
int m_nGroup; /**
char_type m_cDecPoint; * @brief Type used for storing an array of values.
char_type m_cThousandsSep; */
typedef QVector<qreal> valbuf_type;
/**
* @brief Type for a vector of strings.
*/
typedef QVector<QString> stringbuf_type;
/**
* @brief Typedef for the token reader.
*/
typedef QmuParserTokenReader token_reader_type;
/**
* @brief Type used for parser tokens.
*/
typedef QmuParserToken<qreal, QString> token_type;
/**
* @brief Maximum number of threads spawned by OpenMP when using the bulk mode.
*/
static const int s_MaxNumOpenMPThreads = 4;
/**
* @brief Pointer to the parser function.
*
* Eval() calls the function whose address is stored there.
*/
mutable ParseFunction m_pParseFormula;
mutable QmuParserByteCode m_vRPN; ///< The Bytecode class.
mutable stringbuf_type m_vStringBuf; ///< String buffer, used for storing string function arguments
stringbuf_type m_vStringVarBuf;
std::auto_ptr<token_reader_type> m_pTokenReader; ///< Managed pointer to the token reader object.
funmap_type m_FunDef; ///< Map of function names and pointers.
funmap_type m_PostOprtDef; ///< Postfix operator callbacks
funmap_type m_InfixOprtDef; ///< unary infix operator.
funmap_type m_OprtDef; ///< Binary operator callbacks
valmap_type m_ConstDef; ///< user constants.
strmap_type m_StrVarDef; ///< user defined string constants
varmap_type m_VarDef; ///< user defind variables.
bool m_bBuiltInOp; ///< Flag that can be used for switching built in operators on and off
QString m_sNameChars; ///< Charset for names
QString m_sOprtChars; ///< Charset for postfix/ binary operator tokens
QString m_sInfixOprtChars; ///< Charset for infix operator tokens
mutable int m_nIfElseCounter; ///< Internal counter for keeping track of nested if-then-else clauses
// items merely used for caching state information
mutable valbuf_type m_vStackBuffer; ///< This is merely a buffer used for the stack in the cmd parsing routine
mutable int m_nFinalResultIdx;
void Assign(const QmuParserBase &a_Parser);
void InitTokenReader();
void ReInit() const;
void AddCallback(const QString &a_strName, const QmuParserCallback &a_Callback,
funmap_type &a_Storage, const QString &a_szCharSet );
void ApplyRemainingOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyBinOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyIfElse(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyFunc(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal, int iArgCount) const;
token_type ApplyStrFunc(const token_type &a_FunTok, const QVector<token_type> &a_vArg) const;
int GetOprtPrecedence(const token_type &a_Tok) const;
EOprtAssociativity GetOprtAssociativity(const token_type &a_Tok) const;
void CreateRPN() const;
qreal ParseString() const;
qreal ParseCmdCode() const;
qreal ParseCmdCodeBulk(int nOffset, int nThreadID) const;
void CheckName(const QString &a_strName, const QString &a_CharSet) const;
void CheckOprt(const QString &a_sName, const QmuParserCallback &a_Callback,
const QString &a_szCharSet) const;
void StackDump(const QStack<token_type > &a_stVal, const QStack<token_type > &a_stOprt) const;
}; };
private:
void Assign(const QmuParserBase &a_Parser);
void InitTokenReader();
void ReInit() const;
void AddCallback(const QString &a_strName,
const QmuParserCallback &a_Callback,
funmap_type &a_Storage,
const QString &a_szCharSet );
void ApplyRemainingOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyBinOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyIfElse(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyFunc(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal, int iArgCount) const;
token_type ApplyStrFunc(const token_type &a_FunTok,
const QVector<token_type> &a_vArg) const;
int GetOprtPrecedence(const token_type &a_Tok) const;
EOprtAssociativity GetOprtAssociativity(const token_type &a_Tok) const;
void CreateRPN() const;
qreal ParseString() const;
qreal ParseCmdCode() const;
qreal ParseCmdCodeBulk(int nOffset, int nThreadID) const;
void CheckName(const QString &a_strName, const QString &a_CharSet) const;
void CheckOprt(const QString &a_sName,
const QmuParserCallback &a_Callback,
const QString &a_szCharSet) const;
void StackDump(const QStack<token_type > &a_stVal,
const QStack<token_type > &a_stOprt) const;
/** \brief Pointer to the parser function.
Eval() calls the function whose address is stored there.
*/
mutable ParseFunction m_pParseFormula;
mutable QmuParserByteCode m_vRPN; ///< The Bytecode class.
mutable stringbuf_type m_vStringBuf; ///< String buffer, used for storing string function arguments
stringbuf_type m_vStringVarBuf;
std::auto_ptr<token_reader_type> m_pTokenReader; ///< Managed pointer to the token reader object.
funmap_type m_FunDef; ///< Map of function names and pointers.
funmap_type m_PostOprtDef; ///< Postfix operator callbacks
funmap_type m_InfixOprtDef; ///< unary infix operator.
funmap_type m_OprtDef; ///< Binary operator callbacks
valmap_type m_ConstDef; ///< user constants.
strmap_type m_StrVarDef; ///< user defined string constants
varmap_type m_VarDef; ///< user defind variables.
bool m_bBuiltInOp; ///< Flag that can be used for switching built in operators on and off
QString m_sNameChars; ///< Charset for names
QString m_sOprtChars; ///< Charset for postfix/ binary operator tokens
QString m_sInfixOprtChars; ///< Charset for infix operator tokens
mutable int m_nIfElseCounter; ///< Internal counter for keeping track of nested if-then-else clauses
// items merely used for caching state information
mutable valbuf_type m_vStackBuffer; ///< This is merely a buffer used for the stack in the cmd parsing routine
mutable int m_nFinalResultIdx;
};
} // namespace qmu } // namespace qmu
#endif #endif

1143
src/libs/qmuparser/qmuparserbytecode.cpp
View file

File diff suppressed because it is too large Load diff

138
src/libs/qmuparser/qmuparserbytecode.h
View file

@ -23,116 +23,104 @@
#ifndef QMUPARSERBYTECODE_H #ifndef QMUPARSERBYTECODE_H
#define QMUPARSERBYTECODE_H #define QMUPARSERBYTECODE_H
#include <cassert>
#include <string>
#include <stack>
#include "qmuparserdef.h" #include "qmuparserdef.h"
#include "qmuparsererror.h" #include "qmuparsererror.h"
#include "qmuparsertoken.h" #include "qmuparsertoken.h"
/** \file /**
\brief Definition of the parser bytecode class. * @file
*/ * @brief Definition of the parser bytecode class.
*/
namespace qmu namespace qmu
{ {
struct SToken struct SToken
{ {
ECmdCode Cmd; ECmdCode Cmd;
int StackPos; int StackPos;
union union
{ {
struct //SValData struct //SValData
{ {
qreal *ptr; qreal *ptr;
qreal data; qreal data;
qreal data2; qreal data2;
} Val; } Val;
struct //SFunData struct //SFunData
{ {
// Note: generic_fun_type is merely a placeholder. The real type could be // Note: generic_fun_type is merely a placeholder. The real type could be
// anything between gun_type1 and fun_type9. I can't use a void // anything between gun_type1 and fun_type9. I can't use a void
// pointer due to constraints in the ANSI standard which allows // pointer due to constraints in the ANSI standard which allows
// data pointers and function pointers to differ in size. // data pointers and function pointers to differ in size.
generic_fun_type ptr; generic_fun_type ptr;
int argc; int argc;
int idx; int idx;
} Fun; } Fun;
struct //SOprtData struct //SOprtData
{ {
qreal *ptr; qreal *ptr;
int offset; int offset;
} Oprt; } Oprt;
}; };
}; };
/** \brief Bytecode implementation of the Math Parser. /**
* @brief Bytecode implementation of the Math Parser.
The bytecode contains the formula converted to revers polish notation stored in a continious *
memory area. Associated with this data are operator codes, variable pointers, constant * The bytecode contains the formula converted to revers polish notation stored in a continious
values and function pointers. Those are necessary in order to calculate the result. * memory area. Associated with this data are operator codes, variable pointers, constant
All those data items will be casted to the underlying datatype of the bytecode. * values and function pointers. Those are necessary in order to calculate the result.
* All those data items will be casted to the underlying datatype of the bytecode.
\author (C) 2004-2013 Ingo Berg *
*/ * @author (C) 2004-2013 Ingo Berg
*/
class QmuParserByteCode class QmuParserByteCode
{ {
private: private:
/** @brief Token type for internal use only. */
/** \brief Token type for internal use only. */
typedef QmuParserToken<qreal, string_type> token_type; typedef QmuParserToken<qreal, string_type> token_type;
/** \brief Token vector for storing the RPN. */ /** @brief Token vector for storing the RPN. */
typedef QVector<SToken> rpn_type; typedef QVector<SToken> rpn_type;
/** \brief Position in the Calculation array. */ /** @brief Position in the Calculation array. */
unsigned m_iStackPos; unsigned m_iStackPos;
/** \brief Maximum size needed for the stack. */ /** @brief Maximum size needed for the stack. */
std::size_t m_iMaxStackSize; std::size_t m_iMaxStackSize;
/** \brief The actual rpn storage. */ /** @brief The actual rpn storage. */
rpn_type m_vRPN; rpn_type m_vRPN;
bool m_bEnableOptimizer; bool m_bEnableOptimizer;
void ConstantFolding(ECmdCode a_Oprt); void ConstantFolding(ECmdCode a_Oprt);
public: public:
QmuParserByteCode(); QmuParserByteCode();
QmuParserByteCode(const QmuParserByteCode &a_ByteCode); QmuParserByteCode(const QmuParserByteCode &a_ByteCode);
QmuParserByteCode& operator=(const QmuParserByteCode &a_ByteCode); QmuParserByteCode& operator=(const QmuParserByteCode &a_ByteCode);
void Assign(const QmuParserByteCode &a_ByteCode); void Assign(const QmuParserByteCode &a_ByteCode);
void AddVar(qreal *a_pVar);
void AddVar(qreal *a_pVar); void AddVal(qreal a_fVal);
void AddVal(qreal a_fVal); void AddOp(ECmdCode a_Oprt);
void AddOp(ECmdCode a_Oprt); void AddIfElse(ECmdCode a_Oprt);
void AddIfElse(ECmdCode a_Oprt); void AddAssignOp(qreal *a_pVar);
void AddAssignOp(qreal *a_pVar); void AddFun(generic_fun_type a_pFun, int a_iArgc);
void AddFun(generic_fun_type a_pFun, int a_iArgc); void AddBulkFun(generic_fun_type a_pFun, int a_iArgc);
void AddBulkFun(generic_fun_type a_pFun, int a_iArgc); void AddStrFun(generic_fun_type a_pFun, int a_iArgc, int a_iIdx);
void AddStrFun(generic_fun_type a_pFun, int a_iArgc, int a_iIdx); void EnableOptimizer(bool bStat);
void Finalize();
void EnableOptimizer(bool bStat); void clear();
std::size_t GetMaxStackSize() const;
void Finalize(); std::size_t GetSize() const;
void clear();
std::size_t GetMaxStackSize() const;
std::size_t GetSize() const;
const SToken* GetBase() const; const SToken* GetBase() const;
void AsciiDump(); void AsciiDump();
}; };
} // namespace qmu } // namespace qmu
#endif #endif

648
src/libs/qmuparser/qmuparsercallback.cpp
View file

@ -22,439 +22,301 @@
#include "qmuparsercallback.h" #include "qmuparsercallback.h"
/** \file /**
\brief Implementation of the parser callback class. * @file
*/ * @brief Implementation of the parser callback class.
*/
namespace qmu namespace qmu
{ {
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type0 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type0 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 0 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(0) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type1 a_pFun, bool a_bAllowOpti, int a_iPrec, ECmdCode a_iCode) QmuParserCallback::QmuParserCallback ( fun_type1 a_pFun, bool a_bAllowOpti, int a_iPrec, ECmdCode a_iCode )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 1 ), m_iPri ( a_iPrec ), m_eOprtAsct ( oaNONE ), m_iCode ( a_iCode ),
,m_iArgc(1) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(a_iPrec) {}
,m_eOprtAsct(oaNONE)
,m_iCode(a_iCode)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Constructor for constructing funcstion callbacks taking two arguments. /**
\throw nothrow * @brief Constructor for constructing funcstion callbacks taking two arguments.
*/ * @throw nothrow
QmuParserCallback::QmuParserCallback(fun_type2 a_pFun, bool a_bAllowOpti) */
:m_pFun((void*)a_pFun) QmuParserCallback::QmuParserCallback ( fun_type2 a_pFun, bool a_bAllowOpti )
,m_iArgc(2) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 2 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iPri(-1) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_eOprtAsct(oaNONE) {}
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Constructor for constructing binary operator callbacks. /**
\param a_pFun Pointer to a static function taking two arguments * @brief Constructor for constructing binary operator callbacks.
\param a_bAllowOpti A flag indicating this funcation can be optimized * @param a_pFun Pointer to a static function taking two arguments
\param a_iPrec The operator precedence * @param a_bAllowOpti A flag indicating this funcation can be optimized
\param a_eOprtAsct The operators associativity * @param a_iPrec The operator precedence
\throw nothrow * @param a_eOprtAsct The operators associativity
*/ * @throw nothrow
QmuParserCallback::QmuParserCallback(fun_type2 a_pFun, */
bool a_bAllowOpti, QmuParserCallback::QmuParserCallback ( fun_type2 a_pFun, bool a_bAllowOpti, int a_iPrec,
int a_iPrec, EOprtAssociativity a_eOprtAsct )
EOprtAssociativity a_eOprtAsct) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 2 ), m_iPri ( a_iPrec ), m_eOprtAsct ( a_eOprtAsct ),
:m_pFun((void*)a_pFun) m_iCode ( cmOPRT_BIN ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iArgc(2) {}
,m_iPri(a_iPrec)
,m_eOprtAsct(a_eOprtAsct)
,m_iCode(cmOPRT_BIN)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type3 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type3 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 3 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(3) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type4 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type4 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 4 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(4) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type5 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type5 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 5 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(5) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type6 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type6 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 6 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(6) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type7 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type7 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 7 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(7) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type8 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type8 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 8 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(8) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type9 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type9 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 9 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(9) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(fun_type10 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( fun_type10 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 10 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(10) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type0 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type0 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 0 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(0) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type1 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type1 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 1 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(1) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor for constructing funcstion callbacks taking two arguments.
* @throw nothrow
*/
QmuParserCallback::QmuParserCallback ( bulkfun_type2 a_pFun, bool a_bAllowOpti )
: m_pFun ( ( void* ) a_pFun ), m_iArgc ( 2 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Constructor for constructing funcstion callbacks taking two arguments. QmuParserCallback::QmuParserCallback ( bulkfun_type3 a_pFun, bool a_bAllowOpti )
\throw nothrow : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 3 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
*/ m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
QmuParserCallback::QmuParserCallback(bulkfun_type2 a_pFun, bool a_bAllowOpti) {}
:m_pFun((void*)a_pFun)
,m_iArgc(2)
,m_iPri(-1)
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type3 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type4 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 4 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(3) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback ( bulkfun_type5 a_pFun, bool a_bAllowOpti )
: m_pFun ( ( void* ) a_pFun ), m_iArgc ( 5 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type4 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type6 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 6 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(4) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback ( bulkfun_type7 a_pFun, bool a_bAllowOpti )
: m_pFun ( ( void* ) a_pFun ), m_iArgc ( 7 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type5 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type8 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 8 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(5) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type6 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type9 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 9 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(6) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type7 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( bulkfun_type10 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 10 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_BULK ),
,m_iArgc(7) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type8 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( multfun_type a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( -1 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC ),
,m_iArgc(8) m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type9 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( strfun_type1 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 0 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ),
,m_iArgc(9) m_iCode ( cmFUNC_STR ), m_iType ( tpSTR ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(bulkfun_type10 a_pFun, bool a_bAllowOpti) QmuParserCallback::QmuParserCallback ( strfun_type2 a_pFun, bool a_bAllowOpti )
:m_pFun((void*)a_pFun) : m_pFun ( ( void* ) a_pFun ), m_iArgc ( 1 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_STR ),
,m_iArgc(10) m_iType ( tpSTR ), m_bAllowOpti ( a_bAllowOpti )
,m_iPri(-1) {}
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_BULK)
,m_iType(tpDBL)
,m_bAllowOpti(a_bAllowOpti)
{}
//----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback ( strfun_type3 a_pFun, bool a_bAllowOpti )
: m_pFun ( ( void* ) a_pFun ), m_iArgc ( 2 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmFUNC_STR ),
m_iType ( tpSTR ), m_bAllowOpti ( a_bAllowOpti )
{}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(multfun_type a_pFun, bool a_bAllowOpti) /**
:m_pFun((void*)a_pFun) * @brief Default constructor.
,m_iArgc(-1) * @throw nothrow
,m_iPri(-1) */
,m_eOprtAsct(oaNONE) QmuParserCallback::QmuParserCallback()
,m_iCode(cmFUNC) : m_pFun ( 0 ), m_iArgc ( 0 ), m_iPri ( -1 ), m_eOprtAsct ( oaNONE ), m_iCode ( cmUNKNOWN ), m_iType ( tpVOID ),
,m_iType(tpDBL) m_bAllowOpti ( 0 )
,m_bAllowOpti(a_bAllowOpti) {}
{}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy constructor.
* @throw nothrow
*/
QmuParserCallback::QmuParserCallback ( const QmuParserCallback &ref )
{
m_pFun = ref.m_pFun;
m_iArgc = ref.m_iArgc;
m_bAllowOpti = ref.m_bAllowOpti;
m_iCode = ref.m_iCode;
m_iType = ref.m_iType;
m_iPri = ref.m_iPri;
m_eOprtAsct = ref.m_eOprtAsct;
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(strfun_type1 a_pFun, bool a_bAllowOpti) /**
:m_pFun((void*)a_pFun) * @brief Clone this instance and return a pointer to the new instance.
,m_iArgc(0) */
,m_iPri(-1) QmuParserCallback* QmuParserCallback::Clone() const
,m_eOprtAsct(oaNONE) {
,m_iCode(cmFUNC_STR) return new QmuParserCallback ( *this );
,m_iType(tpSTR) }
,m_bAllowOpti(a_bAllowOpti)
{}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Return tru if the function is conservative.
*
* Conservative functions return always the same result for the same argument.
* @throw nothrow
*/
bool QmuParserCallback::IsOptimizable() const
{
return m_bAllowOpti;
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(strfun_type2 a_pFun, bool a_bAllowOpti) /**
:m_pFun((void*)a_pFun) * @brief Get the callback address for the parser function.
,m_iArgc(1) *
,m_iPri(-1) * The type of the address is void. It needs to be recasted according to the argument number to the right type.
,m_eOprtAsct(oaNONE) *
,m_iCode(cmFUNC_STR) * @throw nothrow
,m_iType(tpSTR) * @return #pFun
,m_bAllowOpti(a_bAllowOpti) */
{} void* QmuParserCallback::GetAddr() const
{
return m_pFun;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the callback code.
*/
ECmdCode QmuParserCallback::GetCode() const
{
return m_iCode;
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(strfun_type3 a_pFun, bool a_bAllowOpti) ETypeCode QmuParserCallback::GetType() const
:m_pFun((void*)a_pFun) {
,m_iArgc(2) return m_iType;
,m_iPri(-1) }
,m_eOprtAsct(oaNONE)
,m_iCode(cmFUNC_STR)
,m_iType(tpSTR)
,m_bAllowOpti(a_bAllowOpti)
{}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the operator precedence.
* @throw nothrown
*
* Only valid if the callback token is an operator token (binary or infix).
*/
int QmuParserCallback::GetPri() const
{
return m_iPri;
}
//--------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
/** \brief Default constructor. /**
\throw nothrow * @brief Return the operators associativity.
*/ * @throw nothrown
QmuParserCallback::QmuParserCallback() *
:m_pFun(0) * Only valid if the callback token is a binary operator token.
,m_iArgc(0) */
,m_iPri(-1) EOprtAssociativity QmuParserCallback::GetAssociativity() const
,m_eOprtAsct(oaNONE) {
,m_iCode(cmUNKNOWN) return m_eOprtAsct;
,m_iType(tpVOID) }
,m_bAllowOpti(0)
{}
//----------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------- /**
/** \brief Copy constructor. * @brief Returns the number of function Arguments.
\throw nothrow */
*/ int QmuParserCallback::GetArgc() const
QmuParserCallback::QmuParserCallback(const QmuParserCallback &ref) {
{ return m_iArgc;
m_pFun = ref.m_pFun; }
m_iArgc = ref.m_iArgc;
m_bAllowOpti = ref.m_bAllowOpti;
m_iCode = ref.m_iCode;
m_iType = ref.m_iType;
m_iPri = ref.m_iPri;
m_eOprtAsct = ref.m_eOprtAsct;
}
//---------------------------------------------------------------------------
/** \brief Clone this instance and return a pointer to the new instance. */
QmuParserCallback* QmuParserCallback::Clone() const
{
return new QmuParserCallback(*this);
}
//---------------------------------------------------------------------------
/** \brief Return tru if the function is conservative.
Conservative functions return always the same result for the same argument.
\throw nothrow
*/
bool QmuParserCallback::IsOptimizable() const
{
return m_bAllowOpti;
}
//---------------------------------------------------------------------------
/** \brief Get the callback address for the parser function.
The type of the address is void. It needs to be recasted according to the
argument number to the right type.
\throw nothrow
\return #pFun
*/
void* QmuParserCallback::GetAddr() const
{
return m_pFun;
}
//---------------------------------------------------------------------------
/** \brief Return the callback code. */
ECmdCode QmuParserCallback::GetCode() const
{
return m_iCode;
}
//---------------------------------------------------------------------------
ETypeCode QmuParserCallback::GetType() const
{
return m_iType;
}
//---------------------------------------------------------------------------
/** \brief Return the operator precedence.
\throw nothrown
Only valid if the callback token is an operator token (binary or infix).
*/
int QmuParserCallback::GetPri() const
{
return m_iPri;
}
//---------------------------------------------------------------------------
/** \brief Return the operators associativity.
\throw nothrown
Only valid if the callback token is a binary operator token.
*/
EOprtAssociativity QmuParserCallback::GetAssociativity() const
{
return m_eOprtAsct;
}
//---------------------------------------------------------------------------
/** \brief Returns the number of function Arguments. */
int QmuParserCallback::GetArgc() const
{
return m_iArgc;
}
} // namespace qmu } // namespace qmu

60
src/libs/qmuparser/qmuparsercallback.h
View file

@ -25,25 +25,24 @@
#include "qmuparserdef.h" #include "qmuparserdef.h"
/** \file /**
\brief Definition of the parser callback class. * @file
*/ * @brief Definition of the parser callback class.
*/
namespace qmu namespace qmu
{ {
/** \brief Encapsulation of prototypes for a numerical parser function. /**
* @brief Encapsulation of prototypes for a numerical parser function.
Encapsulates the prototyp for numerical parser functions. The class *
stores the number of arguments for parser functions as well * Encapsulates the prototyp for numerical parser functions. The class stores the number of arguments for parser
as additional flags indication the function is non optimizeable. * functions as well as additional flags indication the function is non optimizeable. The pointer to the callback
The pointer to the callback function pointer is stored as void* * function pointer is stored as void* and needs to be casted according to the argument count. Negative argument counts
and needs to be casted according to the argument count. * indicate a parser function with a variable number of arguments.
Negative argument counts indicate a parser function with a variable number *
of arguments. * @author (C) 2004-2011 Ingo Berg
*/
\author (C) 2004-2011 Ingo Berg
*/
class QmuParserCallback class QmuParserCallback
{ {
public: public:
@ -80,23 +79,22 @@ public:
QmuParserCallback(const QmuParserCallback &a_Fun); QmuParserCallback(const QmuParserCallback &a_Fun);
QmuParserCallback* Clone() const; QmuParserCallback* Clone() const;
bool IsOptimizable() const;
bool IsOptimizable() const; void* GetAddr() const;
void* GetAddr() const; ECmdCode GetCode() const;
ECmdCode GetCode() const; ETypeCode GetType() const;
ETypeCode GetType() const; int GetPri() const;
int GetPri() const;
EOprtAssociativity GetAssociativity() const; EOprtAssociativity GetAssociativity() const;
int GetArgc() const; int GetArgc() const;
private: private:
void *m_pFun; ///< Pointer to the callback function, casted to void void *m_pFun; ///< Pointer to the callback function, casted to void
/** \brief Number of numeric function arguments /**
* @brief Number of numeric function arguments
This number is negative for functions with variable number of arguments. in this cases *
they represent the actual number of arguments found. * This number is negative for functions with variable number of arguments. in this cases
*/ * they represent the actual number of arguments found.
*/
int m_iArgc; int m_iArgc;
int m_iPri; ///< Valid only for binary and infix operators; Operator precedence. int m_iPri; ///< Valid only for binary and infix operators; Operator precedence.
EOprtAssociativity m_eOprtAsct; ///< Operator associativity; Valid only for binary operators EOprtAssociativity m_eOprtAsct; ///< Operator associativity; Valid only for binary operators
@ -105,8 +103,10 @@ private:
bool m_bAllowOpti; ///< Flag indication optimizeability bool m_bAllowOpti; ///< Flag indication optimizeability
}; };
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Container for Callback objects. */ /**
* @brief Container for Callback objects.
*/
typedef std::map<QString, QmuParserCallback> funmap_type; typedef std::map<QString, QmuParserCallback> funmap_type;
} // namespace qmu } // namespace qmu

232
src/libs/qmuparser/qmuparserdef.h
View file

@ -23,17 +23,13 @@
#ifndef QMUPDEF_H #ifndef QMUPDEF_H
#define QMUPDEF_H #define QMUPDEF_H
#include <iostream>
#include <string>
#include <sstream>
#include <map>
#include <QMap> #include <QMap>
#include <QString> #include <QString>
#include "qmuparserfixes.h" #include "qmuparserfixes.h"
/** \file /** @file
\brief This file contains standard definitions used by the parser. @brief This file contains standard definitions used by the parser.
*/ */
#define QMUP_VERSION "2.2.3" #define QMUP_VERSION "2.2.3"
@ -41,32 +37,32 @@
#define QMUP_CHARS "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" #define QMUP_CHARS "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
/** \brief If this macro is defined mathematical exceptions (div by zero) will be thrown as exceptions. */ /** @brief If this macro is defined mathematical exceptions (div by zero) will be thrown as exceptions. */
//#define QMUP_MATH_EXCEPTIONS //#define QMUP_MATH_EXCEPTIONS
/** \brief Activate this option in order to compile with OpenMP support. /** @brief Activate this option in order to compile with OpenMP support.
OpenMP is used only in the bulk mode it may increase the performance a bit. OpenMP is used only in the bulk mode it may increase the performance a bit.
*/ */
//#define MUP_USE_OPENMP //#define MUP_USE_OPENMP
#if defined(_UNICODE) #if defined(_UNICODE)
/** \brief Definition of the basic parser string type. */ /** @brief Definition of the basic parser string type. */
#define QMUP_STRING_TYPE std::wstring #define QMUP_STRING_TYPE std::wstring
#else #else
/** \brief Definition of the basic parser string type. */ /** @brief Definition of the basic parser string type. */
#define QMUP_STRING_TYPE std::string #define QMUP_STRING_TYPE std::string
#endif #endif
namespace qmu namespace qmu
{ {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Bytecode values. /** @brief Bytecode values.
\attention The order of the operator entries must match the order in ParserBase::c_DefaultOprt! \attention The order of the operator entries must match the order in ParserBase::c_DefaultOprt!
*/ */
enum ECmdCode enum ECmdCode
{ {
// The following are codes for built in binary operators // The following are codes for built in binary operators
// apart from built in operators the user has the opportunity to // apart from built in operators the user has the opportunity to
// add user defined operators. // add user defined operators.
@ -110,38 +106,38 @@ namespace qmu
cmOPRT_INFIX, ///< code for infix operators cmOPRT_INFIX, ///< code for infix operators
cmEND, ///< end of formula cmEND, ///< end of formula
cmUNKNOWN ///< uninitialized item cmUNKNOWN ///< uninitialized item
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Types internally used by the parser. /** @brief Types internally used by the parser.
*/ */
enum ETypeCode enum ETypeCode
{ {
tpSTR = 0, ///< String type (Function arguments and constants only, no string variables) tpSTR = 0, ///< String type (Function arguments and constants only, no string variables)
tpDBL = 1, ///< Floating point variables tpDBL = 1, ///< Floating point variables
tpVOID = 2 ///< Undefined type. tpVOID = 2 ///< Undefined type.
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
enum EParserVersionInfo enum EParserVersionInfo
{ {
pviBRIEF, pviBRIEF,
pviFULL pviFULL
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Parser operator precedence values. */ /** @brief Parser operator precedence values. */
enum EOprtAssociativity enum EOprtAssociativity
{ {
oaLEFT = 0, oaLEFT = 0,
oaRIGHT = 1, oaRIGHT = 1,
oaNONE = 2 oaNONE = 2
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Parser operator precedence values. */ /** @brief Parser operator precedence values. */
enum EOprtPrecedence enum EOprtPrecedence
{ {
// binary operators // binary operators
prLOR = 1, prLOR = 1,
prLAND = 2, prLAND = 2,
@ -154,127 +150,125 @@ namespace qmu
// infix operators // infix operators
prINFIX = 6, ///< Signs have a higher priority than ADD_SUB, but lower than power operator prINFIX = 6, ///< Signs have a higher priority than ADD_SUB, but lower than power operator
prPOSTFIX = 6 ///< Postfix operator priority (currently unused) prPOSTFIX = 6 ///< Postfix operator priority (currently unused)
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// basic types // basic types
/** \brief The stringtype used by the parser. /** @brief The stringtype used by the parser.
Depends on wether UNICODE is used or not. Depends on wether UNICODE is used or not.
*/ */
typedef QMUP_STRING_TYPE string_type; typedef QMUP_STRING_TYPE string_type;
/** \brief The character type used by the parser. /** @brief The character type used by the parser.
Depends on wether UNICODE is used or not. Depends on wether UNICODE is used or not.
*/ */
typedef string_type::value_type char_type; typedef string_type::value_type char_type;
/** \brief Typedef for easily using stringstream that respect the parser stringtype. */ /** @brief Typedef for easily using stringstream that respect the parser stringtype. */
typedef std::basic_stringstream<char_type, typedef std::basic_stringstream < char_type, std::char_traits<char_type>, std::allocator<char_type> > stringstream_type;
std::char_traits<char_type>,
std::allocator<char_type> > stringstream_type;
// Data container types // Data container types
/** \brief Type used for storing variables. */ /** @brief Type used for storing variables. */
typedef std::map<QString, qreal*> varmap_type; typedef std::map<QString, qreal*> varmap_type;
/** \brief Type used for storing constants. */ /** @brief Type used for storing constants. */
typedef std::map<QString, qreal> valmap_type; typedef std::map<QString, qreal> valmap_type;
/** \brief Type for assigning a string name to an index in the internal string table. */ /** @brief Type for assigning a string name to an index in the internal string table. */
typedef std::map<QString, int> strmap_type; typedef std::map<QString, int> strmap_type;
// Parser callbacks // Parser callbacks
/** \brief Callback type used for functions without arguments. */ /** @brief Callback type used for functions without arguments. */
typedef qreal (*generic_fun_type)(); typedef qreal ( *generic_fun_type ) ();
/** \brief Callback type used for functions without arguments. */ /** @brief Callback type used for functions without arguments. */
typedef qreal (*fun_type0)(); typedef qreal ( *fun_type0 ) ();
/** \brief Callback type used for functions with a single arguments. */ /** @brief Callback type used for functions with a single arguments. */
typedef qreal (*fun_type1)(qreal); typedef qreal ( *fun_type1 ) ( qreal );
/** \brief Callback type used for functions with two arguments. */ /** @brief Callback type used for functions with two arguments. */
typedef qreal (*fun_type2)(qreal, qreal); typedef qreal ( *fun_type2 ) ( qreal, qreal );
/** \brief Callback type used for functions with three arguments. */ /** @brief Callback type used for functions with three arguments. */
typedef qreal (*fun_type3)(qreal, qreal, qreal); typedef qreal ( *fun_type3 ) ( qreal, qreal, qreal );
/** \brief Callback type used for functions with four arguments. */ /** @brief Callback type used for functions with four arguments. */
typedef qreal (*fun_type4)(qreal, qreal, qreal, qreal); typedef qreal ( *fun_type4 ) ( qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*fun_type5)(qreal, qreal, qreal, qreal, qreal); typedef qreal ( *fun_type5 ) ( qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*fun_type6)(qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *fun_type6 ) ( qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*fun_type7)(qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *fun_type7 ) ( qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*fun_type8)(qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *fun_type8 ) ( qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*fun_type9)(qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *fun_type9 ) ( qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*fun_type10)(qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *fun_type10 ) ( qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions without arguments. */ /** @brief Callback type used for functions without arguments. */
typedef qreal (*bulkfun_type0)(int, int); typedef qreal ( *bulkfun_type0 ) ( int, int );
/** \brief Callback type used for functions with a single arguments. */ /** @brief Callback type used for functions with a single arguments. */
typedef qreal (*bulkfun_type1)(int, int, qreal); typedef qreal ( *bulkfun_type1 ) ( int, int, qreal );
/** \brief Callback type used for functions with two arguments. */ /** @brief Callback type used for functions with two arguments. */
typedef qreal (*bulkfun_type2)(int, int, qreal, qreal); typedef qreal ( *bulkfun_type2 ) ( int, int, qreal, qreal );
/** \brief Callback type used for functions with three arguments. */ /** @brief Callback type used for functions with three arguments. */
typedef qreal (*bulkfun_type3)(int, int, qreal, qreal, qreal); typedef qreal ( *bulkfun_type3 ) ( int, int, qreal, qreal, qreal );
/** \brief Callback type used for functions with four arguments. */ /** @brief Callback type used for functions with four arguments. */
typedef qreal (*bulkfun_type4)(int, int, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type4 ) ( int, int, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*bulkfun_type5)(int, int, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type5 ) ( int, int, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*bulkfun_type6)(int, int, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type6 ) ( int, int, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*bulkfun_type7)(int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type7 ) ( int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*bulkfun_type8)(int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type8 ) ( int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*bulkfun_type9)(int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type9 ) ( int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with five arguments. */ /** @brief Callback type used for functions with five arguments. */
typedef qreal (*bulkfun_type10)(int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal); typedef qreal ( *bulkfun_type10 ) ( int, int, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal );
/** \brief Callback type used for functions with a variable argument list. */ /** @brief Callback type used for functions with a variable argument list. */
typedef qreal (*multfun_type)(const qreal*, int); typedef qreal ( *multfun_type ) ( const qreal*, int );
/** \brief Callback type used for functions taking a string as an argument. */ /** @brief Callback type used for functions taking a string as an argument. */
typedef qreal (*strfun_type1)(const QString &); typedef qreal ( *strfun_type1 ) ( const QString & );
/** \brief Callback type used for functions taking a string and a value as arguments. */ /** @brief Callback type used for functions taking a string and a value as arguments. */
typedef qreal (*strfun_type2)(const QString &, qreal); typedef qreal ( *strfun_type2 ) ( const QString &, qreal );
/** \brief Callback type used for functions taking a string and two values as arguments. */ /** @brief Callback type used for functions taking a string and two values as arguments. */
typedef qreal (*strfun_type3)(const QString &, qreal, qreal); typedef qreal ( *strfun_type3 ) ( const QString &, qreal, qreal );
/** \brief Callback used for functions that identify values in a string. */ /** @brief Callback used for functions that identify values in a string. */
typedef int (*identfun_type)(const QString &sExpr, int *nPos, qreal *fVal); typedef int ( *identfun_type ) ( const QString &sExpr, int *nPos, qreal *fVal );
/** \brief Callback used for variable creation factory functions. */ /** @brief Callback used for variable creation factory functions. */
typedef qreal* (*facfun_type)(const QString &, void*); typedef qreal* ( *facfun_type ) ( const QString &, void* );
} // end of namespace } // end of namespace
#endif #endif

573
src/libs/qmuparser/qmuparsererror.cpp
View file

@ -24,303 +24,306 @@
#include <QTextStream> #include <QTextStream>
namespace qmu namespace qmu
{ {
const QmuParserErrorMsg QmuParserErrorMsg::m_Instance; const QmuParserErrorMsg QmuParserErrorMsg::m_Instance;
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
const QmuParserErrorMsg& QmuParserErrorMsg::Instance() const QmuParserErrorMsg& QmuParserErrorMsg::Instance()
{
return m_Instance;
}
//------------------------------------------------------------------------------
QString QmuParserErrorMsg::operator[](unsigned a_iIdx) const
{
return (a_iIdx<m_vErrMsg.size()) ? m_vErrMsg[a_iIdx] : QString();
}
//---------------------------------------------------------------------------
QmuParserErrorMsg::~QmuParserErrorMsg()
{}
//---------------------------------------------------------------------------
/** \brief Assignement operator is deactivated.
*/
QmuParserErrorMsg& QmuParserErrorMsg::operator=(const QmuParserErrorMsg& )
{
assert(false);
return *this;
}
//---------------------------------------------------------------------------
QmuParserErrorMsg::QmuParserErrorMsg(const QmuParserErrorMsg&)
{}
//---------------------------------------------------------------------------
QmuParserErrorMsg::QmuParserErrorMsg()
:m_vErrMsg(0)
{
m_vErrMsg.resize(ecCOUNT);
m_vErrMsg[ecUNASSIGNABLE_TOKEN] = "Unexpected token \"$TOK$\" found at position $POS$.";
m_vErrMsg[ecINTERNAL_ERROR] = "Internal error";
m_vErrMsg[ecINVALID_NAME] = "Invalid function-, variable- or constant name: \"$TOK$\".";
m_vErrMsg[ecINVALID_BINOP_IDENT] = "Invalid binary operator identifier: \"$TOK$\".";
m_vErrMsg[ecINVALID_INFIX_IDENT] = "Invalid infix operator identifier: \"$TOK$\".";
m_vErrMsg[ecINVALID_POSTFIX_IDENT] = "Invalid postfix operator identifier: \"$TOK$\".";
m_vErrMsg[ecINVALID_FUN_PTR] = "Invalid pointer to callback function.";
m_vErrMsg[ecEMPTY_EXPRESSION] = "Expression is empty.";
m_vErrMsg[ecINVALID_VAR_PTR] = "Invalid pointer to variable.";
m_vErrMsg[ecUNEXPECTED_OPERATOR] = "Unexpected operator \"$TOK$\" found at position $POS$";
m_vErrMsg[ecUNEXPECTED_EOF] = "Unexpected end of expression at position $POS$";
m_vErrMsg[ecUNEXPECTED_ARG_SEP] = "Unexpected argument separator at position $POS$";
m_vErrMsg[ecUNEXPECTED_PARENS] = "Unexpected parenthesis \"$TOK$\" at position $POS$";
m_vErrMsg[ecUNEXPECTED_FUN] = "Unexpected function \"$TOK$\" at position $POS$";
m_vErrMsg[ecUNEXPECTED_VAL] = "Unexpected value \"$TOK$\" found at position $POS$";
m_vErrMsg[ecUNEXPECTED_VAR] = "Unexpected variable \"$TOK$\" found at position $POS$";
m_vErrMsg[ecUNEXPECTED_ARG] = "Function arguments used without a function (position: $POS$)";
m_vErrMsg[ecMISSING_PARENS] = "Missing parenthesis";
m_vErrMsg[ecTOO_MANY_PARAMS] = "Too many parameters for function \"$TOK$\" at expression position $POS$";
m_vErrMsg[ecTOO_FEW_PARAMS] = "Too few parameters for function \"$TOK$\" at expression position $POS$";
m_vErrMsg[ecDIV_BY_ZERO] = "Divide by zero";
m_vErrMsg[ecDOMAIN_ERROR] = "Domain error";
m_vErrMsg[ecNAME_CONFLICT] = "Name conflict";
m_vErrMsg[ecOPT_PRI] = "Invalid value for operator priority (must be greater or equal to zero).";
m_vErrMsg[ecBUILTIN_OVERLOAD] = "user defined binary operator \"$TOK$\" conflicts with a built in operator.";
m_vErrMsg[ecUNEXPECTED_STR] = "Unexpected string token found at position $POS$.";
m_vErrMsg[ecUNTERMINATED_STRING] = "Unterminated string starting at position $POS$.";
m_vErrMsg[ecSTRING_EXPECTED] = "String function called with a non string type of argument.";
m_vErrMsg[ecVAL_EXPECTED] = "String value used where a numerical argument is expected.";
m_vErrMsg[ecOPRT_TYPE_CONFLICT] = "No suitable overload for operator \"$TOK$\" at position $POS$.";
m_vErrMsg[ecSTR_RESULT] = "Function result is a string.";
m_vErrMsg[ecGENERIC] = "Parser error.";
m_vErrMsg[ecLOCALE] = "Decimal separator is identic to function argument separator.";
m_vErrMsg[ecUNEXPECTED_CONDITIONAL] = "The \"$TOK$\" operator must be preceeded by a closing bracket.";
m_vErrMsg[ecMISSING_ELSE_CLAUSE] = "If-then-else operator is missing an else clause";
m_vErrMsg[ecMISPLACED_COLON] = "Misplaced colon at position $POS$";
#if defined(_DEBUG)
for (int i=0; i<ecCOUNT; ++i)
if (!m_vErrMsg[i].length())
assert(false);
#endif
}
//---------------------------------------------------------------------------
//
// QParserError class
//
//---------------------------------------------------------------------------
/** \brief Default constructor. */
QmuParserError::QmuParserError()
:m_strMsg()
,m_strFormula()
,m_strTok()
,m_iPos(-1)
,m_iErrc(ecUNDEFINED)
,m_ErrMsg(QmuParserErrorMsg::Instance())
{
}
//------------------------------------------------------------------------------
/** \brief This Constructor is used for internal exceptions only.
It does not contain any information but the error code.
*/
QmuParserError::QmuParserError(EErrorCodes a_iErrc)
:m_strMsg()
,m_strFormula()
,m_strTok()
,m_iPos(-1)
,m_iErrc(a_iErrc)
,m_ErrMsg(QmuParserErrorMsg::Instance())
{
m_strMsg = m_ErrMsg[m_iErrc];
ReplaceSubString(m_strMsg, "$POS$", QString().setNum(m_iPos));
ReplaceSubString(m_strMsg, "$TOK$", m_strTok);
}
//------------------------------------------------------------------------------
/** \brief Construct an error from a message text. */
QmuParserError::QmuParserError(const QString &sMsg)
:m_ErrMsg(QmuParserErrorMsg::Instance())
{
Reset();
m_strMsg = sMsg;
}
//------------------------------------------------------------------------------
/** \brief Construct an error object.
\param [in] a_iErrc the error code.
\param [in] sTok The token string related to this error.
\param [in] sExpr The expression related to the error.
\param [in] a_iPos the position in the expression where the error occured.
*/
QmuParserError::QmuParserError(EErrorCodes iErrc,
const QString &sTok,
const QString &sExpr,
int iPos )
:m_strMsg()
,m_strFormula(sExpr)
,m_strTok(sTok)
,m_iPos(iPos)
,m_iErrc(iErrc)
,m_ErrMsg(QmuParserErrorMsg::Instance())
{
m_strMsg = m_ErrMsg[m_iErrc];
ReplaceSubString(m_strMsg, "$POS$", QString().setNum(m_iPos));
ReplaceSubString(m_strMsg, "$TOK$", m_strTok);
}
//------------------------------------------------------------------------------
/** \brief Construct an error object.
\param [in] iErrc the error code.
\param [in] iPos the position in the expression where the error occured.
\param [in] sTok The token string related to this error.
*/
QmuParserError::QmuParserError(EErrorCodes iErrc, int iPos, const QString &sTok)
:m_strMsg()
,m_strFormula()
,m_strTok(sTok)
,m_iPos(iPos)
,m_iErrc(iErrc)
,m_ErrMsg(QmuParserErrorMsg::Instance())
{
m_strMsg = m_ErrMsg[m_iErrc];
ReplaceSubString(m_strMsg, "$POS$", QString().setNum(m_iPos));
ReplaceSubString(m_strMsg, "$TOK$", m_strTok);
}
//------------------------------------------------------------------------------
/** \brief Construct an error object.
\param [in] szMsg The error message text.
\param [in] iPos the position related to the error.
\param [in] sTok The token string related to this error.
*/
QmuParserError::QmuParserError(const QString &szMsg, int iPos, const QString &sTok)
:m_strMsg(szMsg)
,m_strFormula()
,m_strTok(sTok)
,m_iPos(iPos)
,m_iErrc(ecGENERIC)
,m_ErrMsg(QmuParserErrorMsg::Instance())
{
ReplaceSubString(m_strMsg, "$POS$", QString().setNum(m_iPos));
ReplaceSubString(m_strMsg, "$TOK$", m_strTok);
}
//------------------------------------------------------------------------------
/** \brief Copy constructor. */
QmuParserError::QmuParserError(const QmuParserError &a_Obj)
:m_strMsg(a_Obj.m_strMsg)
,m_strFormula(a_Obj.m_strFormula)
,m_strTok(a_Obj.m_strTok)
,m_iPos(a_Obj.m_iPos)
,m_iErrc(a_Obj.m_iErrc)
,m_ErrMsg(QmuParserErrorMsg::Instance())
{
}
//------------------------------------------------------------------------------
/** \brief Assignment operator. */
QmuParserError& QmuParserError::operator=(const QmuParserError &a_Obj)
{
if (this==&a_Obj)
return *this;
m_strMsg = a_Obj.m_strMsg;
m_strFormula = a_Obj.m_strFormula;
m_strTok = a_Obj.m_strTok;
m_iPos = a_Obj.m_iPos;
m_iErrc = a_Obj.m_iErrc;
return *this;
}
//------------------------------------------------------------------------------
QmuParserError::~QmuParserError()
{}
//------------------------------------------------------------------------------
/** \brief Replace all ocuurences of a substring with another string.
\param strFind The string that shall be replaced.
\param strReplaceWith The string that should be inserted instead of strFind
*/
void QmuParserError::ReplaceSubString( QString &strSource, const QString &strFind, const QString &strReplaceWith)
{ {
QString strResult; return m_Instance;
int iPos(0), iNext(0);
for(;;)
{
iNext = strSource.indexOf(strFind, iPos);
strResult.append(strSource.mid(iPos, iNext-iPos));
if( iNext==-1 )
break;
strResult.append(strReplaceWith);
iPos = iNext + strFind.length();
}
strSource.swap(strResult);
} }
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Reset the erro object. */ QString QmuParserErrorMsg::operator[] ( unsigned a_iIdx ) const
void QmuParserError::Reset() {
{ return ( a_iIdx < m_vErrMsg.size() ) ? m_vErrMsg[a_iIdx] : QString();
m_strMsg = ""; }
m_strFormula = "";
m_strTok = "";
m_iPos = -1;
m_iErrc = ecUNDEFINED;
}
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Set the expression related to this error. */ QmuParserErrorMsg::~QmuParserErrorMsg()
void QmuParserError::SetFormula(const QString &a_strFormula) {}
{
m_strFormula = a_strFormula;
}
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief gets the expression related tp this error.*/ /**
const QString& QmuParserError::GetExpr() const * @brief Assignement operator is deactivated.
{ */
return m_strFormula; QmuParserErrorMsg& QmuParserErrorMsg::operator= ( const QmuParserErrorMsg& )
} {
assert ( false );
return *this;
}
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Returns the message string for this error. */ QmuParserErrorMsg::QmuParserErrorMsg ( const QmuParserErrorMsg& )
const QString& QmuParserError::GetMsg() const {}
{
return m_strMsg;
}
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Return the formula position related to the error. QmuParserErrorMsg::QmuParserErrorMsg()
: m_vErrMsg ( 0 )
{
m_vErrMsg.resize ( ecCOUNT );
If the error is not related to a distinct position this will return -1 m_vErrMsg[ecUNASSIGNABLE_TOKEN] = "Unexpected token \"$TOK$\" found at position $POS$.";
m_vErrMsg[ecINTERNAL_ERROR] = "Internal error";
m_vErrMsg[ecINVALID_NAME] = "Invalid function-, variable- or constant name: \"$TOK$\".";
m_vErrMsg[ecINVALID_BINOP_IDENT] = "Invalid binary operator identifier: \"$TOK$\".";
m_vErrMsg[ecINVALID_INFIX_IDENT] = "Invalid infix operator identifier: \"$TOK$\".";
m_vErrMsg[ecINVALID_POSTFIX_IDENT] = "Invalid postfix operator identifier: \"$TOK$\".";
m_vErrMsg[ecINVALID_FUN_PTR] = "Invalid pointer to callback function.";
m_vErrMsg[ecEMPTY_EXPRESSION] = "Expression is empty.";
m_vErrMsg[ecINVALID_VAR_PTR] = "Invalid pointer to variable.";
m_vErrMsg[ecUNEXPECTED_OPERATOR] = "Unexpected operator \"$TOK$\" found at position $POS$";
m_vErrMsg[ecUNEXPECTED_EOF] = "Unexpected end of expression at position $POS$";
m_vErrMsg[ecUNEXPECTED_ARG_SEP] = "Unexpected argument separator at position $POS$";
m_vErrMsg[ecUNEXPECTED_PARENS] = "Unexpected parenthesis \"$TOK$\" at position $POS$";
m_vErrMsg[ecUNEXPECTED_FUN] = "Unexpected function \"$TOK$\" at position $POS$";
m_vErrMsg[ecUNEXPECTED_VAL] = "Unexpected value \"$TOK$\" found at position $POS$";
m_vErrMsg[ecUNEXPECTED_VAR] = "Unexpected variable \"$TOK$\" found at position $POS$";
m_vErrMsg[ecUNEXPECTED_ARG] = "Function arguments used without a function (position: $POS$)";
m_vErrMsg[ecMISSING_PARENS] = "Missing parenthesis";
m_vErrMsg[ecTOO_MANY_PARAMS] = "Too many parameters for function \"$TOK$\" at expression position $POS$";
m_vErrMsg[ecTOO_FEW_PARAMS] = "Too few parameters for function \"$TOK$\" at expression position $POS$";
m_vErrMsg[ecDIV_BY_ZERO] = "Divide by zero";
m_vErrMsg[ecDOMAIN_ERROR] = "Domain error";
m_vErrMsg[ecNAME_CONFLICT] = "Name conflict";
m_vErrMsg[ecOPT_PRI] = "Invalid value for operator priority (must be greater or equal to zero).";
m_vErrMsg[ecBUILTIN_OVERLOAD] = "user defined binary operator \"$TOK$\" conflicts with a built in operator.";
m_vErrMsg[ecUNEXPECTED_STR] = "Unexpected string token found at position $POS$.";
m_vErrMsg[ecUNTERMINATED_STRING] = "Unterminated string starting at position $POS$.";
m_vErrMsg[ecSTRING_EXPECTED] = "String function called with a non string type of argument.";
m_vErrMsg[ecVAL_EXPECTED] = "String value used where a numerical argument is expected.";
m_vErrMsg[ecOPRT_TYPE_CONFLICT] = "No suitable overload for operator \"$TOK$\" at position $POS$.";
m_vErrMsg[ecSTR_RESULT] = "Function result is a string.";
m_vErrMsg[ecGENERIC] = "Parser error.";
m_vErrMsg[ecLOCALE] = "Decimal separator is identic to function argument separator.";
m_vErrMsg[ecUNEXPECTED_CONDITIONAL] = "The \"$TOK$\" operator must be preceeded by a closing bracket.";
m_vErrMsg[ecMISSING_ELSE_CLAUSE] = "If-then-else operator is missing an else clause";
m_vErrMsg[ecMISPLACED_COLON] = "Misplaced colon at position $POS$";
#if defined(_DEBUG)
for ( int i = 0; i < ecCOUNT; ++i )
{
if ( !m_vErrMsg[i].length() )
{
assert ( false );
}
}
#endif
}
//----------------------------------------------------------------------------------------------------------------------
//
// QParserError class
//
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Default constructor.
*/
QmuParserError::QmuParserError()
: m_strMsg(), m_strFormula(), m_strTok(), m_iPos ( -1 ), m_iErrc ( ecUNDEFINED ),
m_ErrMsg ( QmuParserErrorMsg::Instance() )
{
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief This Constructor is used for internal exceptions only.
*
* It does not contain any information but the error code.
*/
QmuParserError::QmuParserError ( EErrorCodes a_iErrc )
: m_strMsg(), m_strFormula(), m_strTok(), m_iPos ( -1 ), m_iErrc ( a_iErrc ),
m_ErrMsg ( QmuParserErrorMsg::Instance() )
{
m_strMsg = m_ErrMsg[m_iErrc];
ReplaceSubString ( m_strMsg, "$POS$", QString().setNum ( m_iPos ) );
ReplaceSubString ( m_strMsg, "$TOK$", m_strTok );
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Construct an error from a message text.
*/
QmuParserError::QmuParserError ( const QString &sMsg )
: m_ErrMsg ( QmuParserErrorMsg::Instance() )
{
Reset();
m_strMsg = sMsg;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Construct an error object.
* @param [in] a_iErrc the error code.
* @param [in] sTok The token string related to this error.
* @param [in] sExpr The expression related to the error.
* @param [in] a_iPos the position in the expression where the error occured.
*/
QmuParserError::QmuParserError ( EErrorCodes iErrc,
const QString &sTok,
const QString &sExpr,
int iPos )
: m_strMsg(), m_strFormula ( sExpr ), m_strTok ( sTok ), m_iPos ( iPos ), m_iErrc ( iErrc ),
m_ErrMsg ( QmuParserErrorMsg::Instance() )
{
m_strMsg = m_ErrMsg[m_iErrc];
ReplaceSubString ( m_strMsg, "$POS$", QString().setNum ( m_iPos ) );
ReplaceSubString ( m_strMsg, "$TOK$", m_strTok );
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Construct an error object.
* @param [in] iErrc the error code.
* @param [in] iPos the position in the expression where the error occured.
* @param [in] sTok The token string related to this error.
*/
QmuParserError::QmuParserError ( EErrorCodes iErrc, int iPos, const QString &sTok )
: m_strMsg(), m_strFormula(), m_strTok ( sTok ), m_iPos ( iPos ), m_iErrc ( iErrc ),
m_ErrMsg ( QmuParserErrorMsg::Instance() )
{
m_strMsg = m_ErrMsg[m_iErrc];
ReplaceSubString ( m_strMsg, "$POS$", QString().setNum ( m_iPos ) );
ReplaceSubString ( m_strMsg, "$TOK$", m_strTok );
}
//----------------------------------------------------------------------------------------------------------------------
/** @brief Construct an error object.
* @param [in] szMsg The error message text.
* @param [in] iPos the position related to the error.
* @param [in] sTok The token string related to this error.
*/ */
std::size_t QmuParserError::GetPos() const QmuParserError::QmuParserError ( const QString &szMsg, int iPos, const QString &sTok )
{ : m_strMsg ( szMsg ), m_strFormula(), m_strTok ( sTok ), m_iPos ( iPos ), m_iErrc ( ecGENERIC ),
return m_iPos; m_ErrMsg ( QmuParserErrorMsg::Instance() )
} {
ReplaceSubString ( m_strMsg, "$POS$", QString().setNum ( m_iPos ) );
ReplaceSubString ( m_strMsg, "$TOK$", m_strTok );
}
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Return string related with this token (if available). */ /** @brief Copy constructor. */
const QString& QmuParserError::GetToken() const QmuParserError::QmuParserError ( const QmuParserError &a_Obj )
{ : m_strMsg ( a_Obj.m_strMsg ), m_strFormula ( a_Obj.m_strFormula ), m_strTok ( a_Obj.m_strTok ),
return m_strTok; m_iPos ( a_Obj.m_iPos ), m_iErrc ( a_Obj.m_iErrc ), m_ErrMsg ( QmuParserErrorMsg::Instance() )
} {
}
//------------------------------------------------------------------------------ //----------------------------------------------------------------------------------------------------------------------
/** \brief Return the error code. */ /** @brief Assignment operator. */
EErrorCodes QmuParserError::GetCode() const QmuParserError& QmuParserError::operator= ( const QmuParserError &a_Obj )
{ {
return m_iErrc; if ( this == &a_Obj )
} {
return *this;
}
m_strMsg = a_Obj.m_strMsg;
m_strFormula = a_Obj.m_strFormula;
m_strTok = a_Obj.m_strTok;
m_iPos = a_Obj.m_iPos;
m_iErrc = a_Obj.m_iErrc;
return *this;
}
//----------------------------------------------------------------------------------------------------------------------
QmuParserError::~QmuParserError()
{}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Replace all ocuurences of a substring with another string.
* @param strFind The string that shall be replaced.
* @param strReplaceWith The string that should be inserted instead of strFind
*/
void QmuParserError::ReplaceSubString ( QString &strSource, const QString &strFind, const QString &strReplaceWith )
{
QString strResult;
int iPos ( 0 ), iNext ( 0 );
for ( ;; )
{
iNext = strSource.indexOf ( strFind, iPos );
strResult.append ( strSource.mid ( iPos, iNext - iPos ) );
if ( iNext == -1 )
break;
strResult.append ( strReplaceWith );
iPos = iNext + strFind.length();
}
strSource.swap ( strResult );
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Reset the erro object.
*/
void QmuParserError::Reset()
{
m_strMsg = "";
m_strFormula = "";
m_strTok = "";
m_iPos = -1;
m_iErrc = ecUNDEFINED;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Set the expression related to this error.
*/
void QmuParserError::SetFormula ( const QString &a_strFormula )
{
m_strFormula = a_strFormula;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief gets the expression related tp this error.
*/
const QString& QmuParserError::GetExpr() const
{
return m_strFormula;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Returns the message string for this error.
*/
const QString& QmuParserError::GetMsg() const
{
return m_strMsg;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the formula position related to the error.
*
* If the error is not related to a distinct position this will return -1
*/
std::size_t QmuParserError::GetPos() const
{
return m_iPos;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Return string related with this token (if available).
*/
const QString& QmuParserError::GetToken() const
{
return m_strTok;
}
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the error code.
*/
EErrorCodes QmuParserError::GetCode() const
{
return m_iErrc;
}
} // namespace qmu } // namespace qmu

172
src/libs/qmuparser/qmuparsererror.h
View file

@ -31,130 +31,126 @@
#include "qmuparserdef.h" #include "qmuparserdef.h"
/** \file /** @file
\brief This file defines the error class used by the parser. @brief This file defines the error class used by the parser.
*/ */
namespace qmu namespace qmu
{ {
/** \brief Error codes. */ /** @brief Error codes. */
enum EErrorCodes enum EErrorCodes
{ {
// Formula syntax errors // Formula syntax errors
ecUNEXPECTED_OPERATOR = 0, ///< Unexpected binary operator found ecUNEXPECTED_OPERATOR = 0, ///< Unexpected binary operator found
ecUNASSIGNABLE_TOKEN = 1, ///< Token cant be identified. ecUNASSIGNABLE_TOKEN = 1, ///< Token cant be identified.
ecUNEXPECTED_EOF = 2, ///< Unexpected end of formula. (Example: "2+sin(") ecUNEXPECTED_EOF = 2, ///< Unexpected end of formula. (Example: "2+sin(")
ecUNEXPECTED_ARG_SEP = 3, ///< An unexpected comma has been found. (Example: "1,23") ecUNEXPECTED_ARG_SEP = 3, ///< An unexpected comma has been found. (Example: "1,23")
ecUNEXPECTED_ARG = 4, ///< An unexpected argument has been found ecUNEXPECTED_ARG = 4, ///< An unexpected argument has been found
ecUNEXPECTED_VAL = 5, ///< An unexpected value token has been found ecUNEXPECTED_VAL = 5, ///< An unexpected value token has been found
ecUNEXPECTED_VAR = 6, ///< An unexpected variable token has been found ecUNEXPECTED_VAR = 6, ///< An unexpected variable token has been found
ecUNEXPECTED_PARENS = 7, ///< Unexpected Parenthesis, opening or closing ecUNEXPECTED_PARENS = 7, ///< Unexpected Parenthesis, opening or closing
ecUNEXPECTED_STR = 8, ///< A string has been found at an inapropriate position ecUNEXPECTED_STR = 8, ///< A string has been found at an inapropriate position
ecSTRING_EXPECTED = 9, ///< A string function has been called with a different type of argument ecSTRING_EXPECTED = 9, ///< A string function has been called with a different type of argument
ecVAL_EXPECTED = 10, ///< A numerical function has been called with a non value type of argument ecVAL_EXPECTED = 10, ///< A numerical function has been called with a non value type of argument
ecMISSING_PARENS = 11, ///< Missing parens. (Example: "3*sin(3") ecMISSING_PARENS = 11, ///< Missing parens. (Example: "3*sin(3")
ecUNEXPECTED_FUN = 12, ///< Unexpected function found. (Example: "sin(8)cos(9)") ecUNEXPECTED_FUN = 12, ///< Unexpected function found. (Example: "sin(8)cos(9)")
ecUNTERMINATED_STRING = 13, ///< unterminated string constant. (Example: "3*valueof("hello)") ecUNTERMINATED_STRING = 13, ///< unterminated string constant. (Example: "3*valueof("hello)")
ecTOO_MANY_PARAMS = 14, ///< Too many function parameters ecTOO_MANY_PARAMS = 14, ///< Too many function parameters
ecTOO_FEW_PARAMS = 15, ///< Too few function parameters. (Example: "ite(1<2,2)") ecTOO_FEW_PARAMS = 15, ///< Too few function parameters. (Example: "ite(1<2,2)")
ecOPRT_TYPE_CONFLICT = 16, ///< binary operators may only be applied to value items of the same type ecOPRT_TYPE_CONFLICT = 16, ///< binary operators may only be applied to value items of the same type
ecSTR_RESULT = 17, ///< result is a string ecSTR_RESULT = 17, ///< result is a string
// Invalid Parser input Parameters // Invalid Parser input Parameters
ecINVALID_NAME = 18, ///< Invalid function, variable or constant name. ecINVALID_NAME = 18, ///< Invalid function, variable or constant name.
ecINVALID_BINOP_IDENT = 19, ///< Invalid binary operator identifier ecINVALID_BINOP_IDENT = 19, ///< Invalid binary operator identifier
ecINVALID_INFIX_IDENT = 20, ///< Invalid function, variable or constant name. ecINVALID_INFIX_IDENT = 20, ///< Invalid function, variable or constant name.
ecINVALID_POSTFIX_IDENT = 21, ///< Invalid function, variable or constant name. ecINVALID_POSTFIX_IDENT = 21, ///< Invalid function, variable or constant name.
ecBUILTIN_OVERLOAD = 22, ///< Trying to overload builtin operator ecBUILTIN_OVERLOAD = 22, ///< Trying to overload builtin operator
ecINVALID_FUN_PTR = 23, ///< Invalid callback function pointer ecINVALID_FUN_PTR = 23, ///< Invalid callback function pointer
ecINVALID_VAR_PTR = 24, ///< Invalid variable pointer ecINVALID_VAR_PTR = 24, ///< Invalid variable pointer
ecEMPTY_EXPRESSION = 25, ///< The Expression is empty ecEMPTY_EXPRESSION = 25, ///< The Expression is empty
ecNAME_CONFLICT = 26, ///< Name conflict ecNAME_CONFLICT = 26, ///< Name conflict
ecOPT_PRI = 27, ///< Invalid operator priority ecOPT_PRI = 27, ///< Invalid operator priority
// //
ecDOMAIN_ERROR = 28, ///< catch division by zero, sqrt(-1), log(0) (currently unused) ecDOMAIN_ERROR = 28, ///< catch division by zero, sqrt(-1), log(0) (currently unused)
ecDIV_BY_ZERO = 29, ///< Division by zero (currently unused) ecDIV_BY_ZERO = 29, ///< Division by zero (currently unused)
ecGENERIC = 30, ///< Generic error ecGENERIC = 30, ///< Generic error
ecLOCALE = 31, ///< Conflict with current locale ecLOCALE = 31, ///< Conflict with current locale
ecUNEXPECTED_CONDITIONAL = 32, ecUNEXPECTED_CONDITIONAL = 32,
ecMISSING_ELSE_CLAUSE = 33, ecMISSING_ELSE_CLAUSE = 33,
ecMISPLACED_COLON = 34, ecMISPLACED_COLON = 34,
// internal errors // internal errors
ecINTERNAL_ERROR = 35, ///< Internal error of any kind. ecINTERNAL_ERROR = 35, ///< Internal error of any kind.
// The last two are special entries // The last two are special entries
ecCOUNT, ///< This is no error code, It just stores just the total number of error codes ecCOUNT, ///< This is no error code, It just stores just the total number of error codes
ecUNDEFINED = -1 ///< Undefined message, placeholder to detect unassigned error messages ecUNDEFINED = -1 ///< Undefined message, placeholder to detect unassigned error messages
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
/** \brief A class that handles the error messages. /** @brief A class that handles the error messages.
*/ */
class QmuParserErrorMsg class QmuParserErrorMsg
{ {
public: public:
typedef QmuParserErrorMsg self_type; typedef QmuParserErrorMsg self_type;
QmuParserErrorMsg& operator=(const QmuParserErrorMsg &); QmuParserErrorMsg& operator= ( const QmuParserErrorMsg & );
QmuParserErrorMsg(const QmuParserErrorMsg&); QmuParserErrorMsg ( const QmuParserErrorMsg& );
QmuParserErrorMsg(); QmuParserErrorMsg();
~QmuParserErrorMsg();
~QmuParserErrorMsg(); static const QmuParserErrorMsg& Instance();
QString operator[] ( unsigned a_iIdx ) const;
static const QmuParserErrorMsg& Instance();
QString operator[](unsigned a_iIdx) const;
private: private:
QVector<QString> m_vErrMsg; ///< A vector with the predefined error messages QVector<QString> m_vErrMsg; ///< A vector with the predefined error messages
static const self_type m_Instance; ///< The instance pointer static const self_type m_Instance; ///< The instance pointer
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
/** \brief Error class of the parser. /** @brief Error class of the parser.
\author Ingo Berg @author Ingo Berg
Part of the math parser package. Part of the math parser package.
*/ */
class QmuParserError class QmuParserError
{ {
private:
/** \brief Replace all ocuurences of a substring with another string. */
void ReplaceSubString(QString &strSource,
const QString &strFind,
const QString &strReplaceWith);
void Reset();
public: public:
QmuParserError(); QmuParserError();
explicit QmuParserError(EErrorCodes a_iErrc); explicit QmuParserError ( EErrorCodes a_iErrc );
explicit QmuParserError(const QString &sMsg); explicit QmuParserError ( const QString &sMsg );
QmuParserError( EErrorCodes a_iErrc, const QString &sTok, const QString &sFormula = QString(), int a_iPos = -1); QmuParserError ( EErrorCodes a_iErrc, const QString &sTok, const QString &sFormula = QString(), int a_iPos = -1 );
QmuParserError(EErrorCodes a_iErrc, int a_iPos, const QString &sTok); QmuParserError ( EErrorCodes a_iErrc, int a_iPos, const QString &sTok );
QmuParserError(const QString &a_szMsg, int a_iPos, const QString &sTok = QString()); QmuParserError ( const QString &a_szMsg, int a_iPos, const QString &sTok = QString() );
QmuParserError(const QmuParserError &a_Obj); QmuParserError ( const QmuParserError &a_Obj );
QmuParserError& operator=(const QmuParserError &a_Obj); QmuParserError& operator= ( const QmuParserError &a_Obj );
~QmuParserError(); ~QmuParserError();
void SetFormula(const QString &a_strFormula); void SetFormula ( const QString &a_strFormula );
const QString &GetExpr() const; const QString& GetExpr() const;
const QString &GetMsg() const; const QString& GetMsg() const;
std::size_t GetPos() const; std::size_t GetPos() const;
const QString &GetToken() const; const QString& GetToken() const;
EErrorCodes GetCode() const; EErrorCodes GetCode() const;
private: private:
QString m_strMsg; ///< The message string QString m_strMsg; ///< The message string
QString m_strFormula; ///< Formula string QString m_strFormula; ///< Formula string
QString m_strTok; ///< Token related with the error QString m_strTok; ///< Token related with the error
int m_iPos; ///< Formula position related to the error int m_iPos; ///< Formula position related to the error
EErrorCodes m_iErrc; ///< Error code EErrorCodes m_iErrc; ///< Error code
const QmuParserErrorMsg &m_ErrMsg; const QmuParserErrorMsg &m_ErrMsg;
/**
* @brief Replace all ocuurences of a substring with another string.
*/
void ReplaceSubString ( QString &strSource, const QString &strFind, const QString &strReplaceWith );
void Reset();
}; };
} // namespace qmu } // namespace qmu

4
src/libs/qmuparser/qmuparserfixes.h
View file

@ -23,8 +23,8 @@
#ifndef QMUPARSERFIXES_H #ifndef QMUPARSERFIXES_H
#define QMUPARSERFIXES_H #define QMUPARSERFIXES_H
/** \file /** @file
\brief This file contains compatibility fixes for some platforms. @brief This file contains compatibility fixes for some platforms.
*/ */
// //

2489
src/libs/qmuparser/qmuparsertest.cpp
View file

File diff suppressed because it is too large Load diff

362
src/libs/qmuparser/qmuparsertest.h
View file

@ -29,170 +29,272 @@
#include "qmuparser.h" #include "qmuparser.h"
#include <QString> #include <QString>
/** \file /**
\brief This file contains the parser test class. * @file
*/ * @brief This file contains the parser test class.
*/
namespace qmu namespace qmu
{ {
/** \brief Namespace for test cases. */ /**
namespace Test * @brief Namespace for test cases.
{ */
//------------------------------------------------------------------------------ namespace Test
/** \brief Test cases for unit testing. {
//----------------------------------------------------------------------------------------------------------------------
/**
* @brief Test cases for unit testing.
*
* (C) 2004-2011 Ingo Berg
*/
class QmuParserTester // final
{
public:
typedef int ( QmuParserTester::*testfun_type ) ();
(C) 2004-2011 Ingo Berg QmuParserTester();
*/ void Run();
class QmuParserTester // final private:
{ QVector<testfun_type> m_vTestFun;
private: static int c_iCount;
static int c_iCount;
// Multiarg callbacks void AddTest ( testfun_type a_pFun );
static qreal f1of1(qreal v) { return v;}
static qreal f1of2(qreal v, qreal ) {return v;} // Test Double Parser
static qreal f2of2(qreal , qreal v) {return v;} int EqnTest ( const QString &a_str, double a_fRes, bool a_fPass );
int EqnTestWithVarChange ( const QString &a_str, double a_fRes1, double a_fVar1, double a_fRes2, double a_fVar2 );
int ThrowTest ( const QString &a_str, int a_iErrc, bool a_bFail = true );
static qreal f1of3(qreal v, qreal , qreal ) {return v;} // Multiarg callbacks
static qreal f2of3(qreal , qreal v, qreal ) {return v;} static qreal f1of1 ( qreal v )
static qreal f3of3(qreal , qreal , qreal v) {return v;} {
return v;
}
static qreal f1of4(qreal v, qreal, qreal , qreal ) {return v;} static qreal f1of2 ( qreal v, qreal )
static qreal f2of4(qreal , qreal v, qreal , qreal ) {return v;} {
static qreal f3of4(qreal , qreal, qreal v, qreal ) {return v;} return v;
static qreal f4of4(qreal , qreal, qreal , qreal v) {return v;} }
static qreal f1of5(qreal v, qreal, qreal , qreal , qreal ) { return v; } static qreal f2of2 ( qreal , qreal v )
static qreal f2of5(qreal , qreal v, qreal , qreal , qreal ) { return v; } {
static qreal f3of5(qreal , qreal, qreal v, qreal , qreal ) { return v; } return v;
static qreal f4of5(qreal , qreal, qreal , qreal v, qreal ) { return v; } }
static qreal f5of5(qreal , qreal, qreal , qreal , qreal v) { return v; }
static qreal Min(qreal a_fVal1, qreal a_fVal2) { return (a_fVal1<a_fVal2) ? a_fVal1 : a_fVal2; } static qreal f1of3 ( qreal v, qreal , qreal )
static qreal Max(qreal a_fVal1, qreal a_fVal2) { return (a_fVal1>a_fVal2) ? a_fVal1 : a_fVal2; } {
return v;
}
static qreal plus2(qreal v1) { return v1+2; } static qreal f2of3 ( qreal , qreal v, qreal )
static qreal times3(qreal v1) { return v1*3; } {
static qreal sqr(qreal v1) { return v1*v1; } return v;
static qreal sign(qreal v) { return -v; } }
static qreal add(qreal v1, qreal v2) { return v1+v2; }
static qreal land(qreal v1, qreal v2) { return (int)v1 & (int)v2; }
static qreal f3of3 ( qreal , qreal , qreal v )
{
return v;
}
static qreal FirstArg(const qreal* a_afArg, int a_iArgc) static qreal f1of4 ( qreal v, qreal, qreal , qreal )
{ {
if (!a_iArgc) return v;
throw qmu::QmuParser::exception_type( "too few arguments for function FirstArg." ); }
return a_afArg[0]; static qreal f2of4 ( qreal , qreal v, qreal , qreal )
} {
return v;
}
static qreal LastArg(const qreal* a_afArg, int a_iArgc) static qreal f3of4 ( qreal , qreal, qreal v, qreal )
{ {
if (!a_iArgc) return v;
throw qmu::QmuParser::exception_type( "too few arguments for function LastArg." ); }
return a_afArg[a_iArgc-1]; static qreal f4of4 ( qreal , qreal, qreal , qreal v )
} {
return v;
}
static qreal Sum(const qreal* a_afArg, int a_iArgc) static qreal f1of5 ( qreal v, qreal, qreal , qreal , qreal )
{ {
if (!a_iArgc) return v;
throw qmu::QmuParser::exception_type( "too few arguments for function sum." ); }
qreal fRes=0; static qreal f2of5 ( qreal , qreal v, qreal , qreal , qreal )
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i]; {
return fRes; return v;
} }
static qreal Rnd(qreal v) static qreal f3of5 ( qreal , qreal, qreal v, qreal , qreal )
{ {
return (qreal)(1+(v*std::rand()/(RAND_MAX+1.0))); return v;
} }
static qreal RndWithString(const char_type*) static qreal f4of5 ( qreal , qreal, qreal , qreal v, qreal )
{ {
return (qreal)( 1 + (1000.0f * std::rand() / (RAND_MAX + 1.0) ) ); return v;
} }
static qreal Ping() static qreal f5of5 ( qreal , qreal, qreal , qreal , qreal v )
{ {
return 10; return v;
} }
static qreal ValueOf(const QString &) static qreal Min ( qreal a_fVal1, qreal a_fVal2 )
{ {
return 123; return ( a_fVal1 < a_fVal2 ) ? a_fVal1 : a_fVal2;
} }
static qreal StrFun1(const QString & v1) static qreal Max ( qreal a_fVal1, qreal a_fVal2 )
{ {
int val = v1.toInt(); return ( a_fVal1 > a_fVal2 ) ? a_fVal1 : a_fVal2;
return (qreal)val; }
}
static qreal StrFun2(const QString & v1, qreal v2) static qreal plus2 ( qreal v1 )
{ {
int val = v1.toInt(); return v1 + 2;
return (qreal)(val + v2); }
}
static qreal StrFun3(const QString & v1, qreal v2, qreal v3) static qreal times3 ( qreal v1 )
{ {
int val = v1.toInt(); return v1 * 3;
return val + v2 + v3; }
}
static qreal StrToFloat(const QString & a_szMsg) static qreal sqr ( qreal v1 )
{ {
qreal val = a_szMsg.toDouble(); return v1 * v1;
return val; }
}
// postfix operator callback static qreal sign ( qreal v )
static qreal Mega(qreal a_fVal) { return a_fVal * (qreal)1e6; } {
static qreal Micro(qreal a_fVal) { return a_fVal * (qreal)1e-6; } return -v;
static qreal Milli(qreal a_fVal) { return a_fVal / (qreal)1e3; } }
// Custom value recognition static qreal add ( qreal v1, qreal v2 )
static int IsHexVal(const QString &a_szExpr, int *a_iPos, qreal *a_fVal); {
return v1 + v2;
}
int TestNames(); static qreal land ( qreal v1, qreal v2 )
int TestSyntax(); {
int TestMultiArg(); return ( int ) v1 & ( int ) v2;
int TestPostFix(); }
int TestExpression();
int TestInfixOprt();
int TestBinOprt();
int TestVarConst();
int TestInterface();
int TestException();
int TestStrArg();
int TestIfThenElse();
void Abort() const; static qreal FirstArg ( const qreal* a_afArg, int a_iArgc )
{
if ( !a_iArgc )
{
throw qmu::QmuParser::exception_type ( "too few arguments for function FirstArg." );
}
public: return a_afArg[0];
typedef int (QmuParserTester::*testfun_type)(); }
QmuParserTester(); static qreal LastArg ( const qreal* a_afArg, int a_iArgc )
void Run(); {
if ( !a_iArgc )
{
throw qmu::QmuParser::exception_type ( "too few arguments for function LastArg." );
}
private: return a_afArg[a_iArgc - 1];
QVector<testfun_type> m_vTestFun; }
void AddTest(testfun_type a_pFun);
// Test Double Parser static qreal Sum ( const qreal* a_afArg, int a_iArgc )
int EqnTest(const QString &a_str, double a_fRes, bool a_fPass); {
int EqnTestWithVarChange(const QString &a_str, if ( !a_iArgc )
double a_fRes1, {
double a_fVar1, throw qmu::QmuParser::exception_type ( "too few arguments for function sum." );
double a_fRes2, }
double a_fVar2);
int ThrowTest(const QString &a_str, int a_iErrc, bool a_bFail = true); qreal fRes = 0;
}; for ( int i = 0; i < a_iArgc; ++i )
} // namespace Test {
fRes += a_afArg[i];
}
return fRes;
}
static qreal Rnd ( qreal v )
{
return ( qreal ) ( 1 + ( v * std::rand() / ( RAND_MAX + 1.0 ) ) );
}
static qreal RndWithString ( const char_type* )
{
return ( qreal ) ( 1 + ( 1000.0f * std::rand() / ( RAND_MAX + 1.0 ) ) );
}
static qreal Ping()
{
return 10;
}
static qreal ValueOf ( const QString & )
{
return 123;
}
static qreal StrFun1 ( const QString & v1 )
{
int val = v1.toInt();
return ( qreal ) val;
}
static qreal StrFun2 ( const QString & v1, qreal v2 )
{
int val = v1.toInt();
return ( qreal ) ( val + v2 );
}
static qreal StrFun3 ( const QString & v1, qreal v2, qreal v3 )
{
int val = v1.toInt();
return val + v2 + v3;
}
static qreal StrToFloat ( const QString & a_szMsg )
{
qreal val = a_szMsg.toDouble();
return val;
}
// postfix operator callback
static qreal Mega ( qreal a_fVal )
{
return a_fVal * ( qreal ) 1e6;
}
static qreal Micro ( qreal a_fVal )
{
return a_fVal * ( qreal ) 1e-6;
}
static qreal Milli ( qreal a_fVal )
{
return a_fVal / ( qreal ) 1e3;
}
// Custom value recognition
static int IsHexVal ( const QString &a_szExpr, int *a_iPos, qreal *a_fVal );
int TestNames();
int TestSyntax();
int TestMultiArg();
int TestPostFix();
int TestExpression();
int TestInfixOprt();
int TestBinOprt();
int TestVarConst();
int TestInterface();
int TestException();
int TestStrArg();
int TestIfThenElse();
void Abort() const;
};
} // namespace Test
} // namespace qmu } // namespace qmu
#endif #endif

92
src/libs/qmuparser/qmuparsertoken.h
View file

@ -32,13 +32,13 @@
#include "qmuparsererror.h" #include "qmuparsererror.h"
#include "qmuparsercallback.h" #include "qmuparsercallback.h"
/** \file /** @file
\brief This file contains the parser token definition. @brief This file contains the parser token definition.
*/ */
namespace qmu namespace qmu
{ {
/** \brief Encapsulation of the data for a single formula token. /** @brief Encapsulation of the data for a single formula token.
Formula token implementation. Part of the Math Parser Package. Formula token implementation. Part of the Math Parser Package.
Formula tokens can be either one of the following: Formula tokens can be either one of the following:
@ -52,7 +52,7 @@ namespace qmu
<li>binary operator</li> <li>binary operator</li>
</ul> </ul>
\author (C) 2004-2013 Ingo Berg @author (C) 2004-2013 Ingo Berg
*/ */
template<typename TBase, typename TString> template<typename TBase, typename TString>
class QmuParserToken class QmuParserToken
@ -71,11 +71,11 @@ namespace qmu
public: public:
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
/** \brief Constructor (default). /** @brief Constructor (default).
Sets token to an neutral state of type cmUNKNOWN. Sets token to an neutral state of type cmUNKNOWN.
\throw nothrow @throw nothrow
\sa ECmdCode @sa ECmdCode
*/ */
QmuParserToken() QmuParserToken()
:m_iCode(cmUNKNOWN) :m_iCode(cmUNKNOWN)
@ -87,12 +87,12 @@ namespace qmu
{} {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Create token from another one. /** @brief Create token from another one.
Implemented by calling Assign(...) Implemented by calling Assign(...)
\throw nothrow @throw nothrow
\post m_iType==cmUNKNOWN @post m_iType==cmUNKNOWN
\sa #Assign @sa #Assign
*/ */
QmuParserToken(const QmuParserToken &a_Tok) QmuParserToken(const QmuParserToken &a_Tok)
{ {
@ -100,11 +100,11 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Assignement operator. /** @brief Assignement operator.
Copy token state from another token and return this. Copy token state from another token and return this.
Implemented by calling Assign(...). Implemented by calling Assign(...).
\throw nothrow @throw nothrow
*/ */
QmuParserToken& operator=(const QmuParserToken &a_Tok) QmuParserToken& operator=(const QmuParserToken &a_Tok)
{ {
@ -113,9 +113,9 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Copy token information from argument. /** @brief Copy token information from argument.
\throw nothrow @throw nothrow
*/ */
void Assign(const QmuParserToken &a_Tok) void Assign(const QmuParserToken &a_Tok)
{ {
@ -131,15 +131,15 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Assign a token type. /** @brief Assign a token type.
Token may not be of type value, variable or function. Those have seperate set functions. Token may not be of type value, variable or function. Those have seperate set functions.
\pre [assert] a_iType!=cmVAR \pre [assert] a_iType!=cmVAR
\pre [assert] a_iType!=cmVAL \pre [assert] a_iType!=cmVAL
\pre [assert] a_iType!=cmFUNC \pre [assert] a_iType!=cmFUNC
\post m_fVal = 0 @post m_fVal = 0
\post m_pTok = 0 @post m_pTok = 0
*/ */
QmuParserToken& Set(ECmdCode a_iType, const TString &a_strTok=TString()) QmuParserToken& Set(ECmdCode a_iType, const TString &a_strTok=TString())
{ {
@ -158,7 +158,7 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Set Callback type. */ /** @brief Set Callback type. */
QmuParserToken& Set(const QmuParserCallback &a_pCallback, const TString &a_sTok) QmuParserToken& Set(const QmuParserCallback &a_pCallback, const TString &a_sTok)
{ {
assert(a_pCallback.GetAddr()); assert(a_pCallback.GetAddr());
@ -175,10 +175,10 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Make this token a value token. /** @brief Make this token a value token.
Member variables not necessary for value tokens will be invalidated. Member variables not necessary for value tokens will be invalidated.
\throw nothrow @throw nothrow
*/ */
QmuParserToken& SetVal(TBase a_fVal, const TString &a_strTok=TString()) QmuParserToken& SetVal(TBase a_fVal, const TString &a_strTok=TString())
{ {
@ -195,10 +195,10 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief make this token a variable token. /** @brief make this token a variable token.
Member variables not necessary for variable tokens will be invalidated. Member variables not necessary for variable tokens will be invalidated.
\throw nothrow @throw nothrow
*/ */
QmuParserToken& SetVar(TBase *a_pVar, const TString &a_strTok) QmuParserToken& SetVar(TBase *a_pVar, const TString &a_strTok)
{ {
@ -212,10 +212,10 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Make this token a variable token. /** @brief Make this token a variable token.
Member variables not necessary for variable tokens will be invalidated. Member variables not necessary for variable tokens will be invalidated.
\throw nothrow @throw nothrow
*/ */
QmuParserToken& SetString(const TString &a_strTok, std::size_t a_iSize) QmuParserToken& SetString(const TString &a_strTok, std::size_t a_iSize)
{ {
@ -230,11 +230,11 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Set an index associated with the token related data. /** @brief Set an index associated with the token related data.
In cmSTRFUNC - This is the index to a string table in the main parser. In cmSTRFUNC - This is the index to a string table in the main parser.
\param a_iIdx The index the string function result will take in the bytecode parser. * @param a_iIdx The index the string function result will take in the bytecode parser.
\throw exception_type if #a_iIdx<0 or #m_iType!=cmSTRING @throw exception_type if #a_iIdx<0 or #m_iType!=cmSTRING
*/ */
void SetIdx(int a_iIdx) void SetIdx(int a_iIdx)
{ {
@ -245,12 +245,12 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Return Index associated with the token related data. /** @brief Return Index associated with the token related data.
In cmSTRFUNC - This is the index to a string table in the main parser. In cmSTRFUNC - This is the index to a string table in the main parser.
\throw exception_type if #m_iIdx<0 or #m_iType!=cmSTRING @throw exception_type if #m_iIdx<0 or #m_iType!=cmSTRING
\return The index the result will take in the Bytecode calculatin array (#m_iIdx). * @return The index the result will take in the Bytecode calculatin array (#m_iIdx).
*/ */
int GetIdx() const int GetIdx() const
{ {
@ -261,10 +261,10 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Return the token type. /** @brief Return the token type.
\return #m_iType * @return #m_iType
\throw nothrow @throw nothrow
*/ */
ECmdCode GetCode() const ECmdCode GetCode() const
{ {
@ -313,11 +313,11 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Return the address of the callback function assoziated with /** @brief Return the address of the callback function assoziated with
function and operator tokens. function and operator tokens.
\return The pointer stored in #m_pTok. * @return The pointer stored in #m_pTok.
\throw exception_type if token type is non of: @throw exception_type if token type is non of:
<ul> <ul>
<li>cmFUNC</li> <li>cmFUNC</li>
<li>cmSTRFUNC</li> <li>cmSTRFUNC</li>
@ -325,7 +325,7 @@ namespace qmu
<li>cmINFIXOP</li> <li>cmINFIXOP</li>
<li>cmOPRT_BIN</li> <li>cmOPRT_BIN</li>
</ul> </ul>
\sa ECmdCode @sa ECmdCode
*/ */
generic_fun_type GetFuncAddr() const generic_fun_type GetFuncAddr() const
{ {
@ -336,7 +336,7 @@ namespace qmu
/** \biref Get value of the token. /** \biref Get value of the token.
Only applicable to variable and value tokens. Only applicable to variable and value tokens.
\throw exception_type if token is no value/variable token. @throw exception_type if token is no value/variable token.
*/ */
TBase GetVal() const TBase GetVal() const
{ {
@ -349,10 +349,10 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Get address of a variable token. /** @brief Get address of a variable token.
Valid only if m_iType==CmdVar. Valid only if m_iType==CmdVar.
\throw exception_type if token is no variable token. @throw exception_type if token is no variable token.
*/ */
TBase* GetVar() const TBase* GetVar() const
{ {
@ -363,7 +363,7 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Return the number of function arguments. /** @brief Return the number of function arguments.
Valid only if m_iType==CmdFUNC. Valid only if m_iType==CmdFUNC.
*/ */
@ -378,13 +378,13 @@ namespace qmu
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** \brief Return the token identifier. /** @brief Return the token identifier.
If #m_iType is cmSTRING the token identifier is the value of the string argument If #m_iType is cmSTRING the token identifier is the value of the string argument
for a string function. for a string function.
\return #m_strTok * @return #m_strTok
\throw nothrow @throw nothrow
\sa m_strTok @sa m_strTok
*/ */
const TString& GetAsString() const const TString& GetAsString() const
{ {

1716
src/libs/qmuparser/qmuparsertokenreader.cpp
View file

File diff suppressed because it is too large Load diff

8
src/libs/qmuparser/qmuparsertokenreader.h
View file

@ -35,8 +35,8 @@
#include "qmuparserdef.h" #include "qmuparserdef.h"
#include "qmuparsertoken.h" #include "qmuparsertoken.h"
/** \file /** @file
\brief This file contains the parser token reader definition. @brief This file contains the parser token reader definition.
*/ */
@ -45,7 +45,7 @@ namespace qmu
// Forward declaration // Forward declaration
class QmuParserBase; class QmuParserBase;
/** \brief Token reader for the ParserBase class. /** @brief Token reader for the ParserBase class.
*/ */
class QmuParserTokenReader class QmuParserTokenReader
@ -75,7 +75,7 @@ namespace qmu
private: private:
/** \brief Syntax codes. /** @brief Syntax codes.
The syntax codes control the syntax check done during the first time parsing of The syntax codes control the syntax check done during the first time parsing of
the expression string. They are flags that indicate which tokens are allowed next the expression string. They are flags that indicate which tokens are allowed next