palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-06-28 15:18:13 +02:00
Code Issues Projects Releases Wiki Activity
valentina/src/libs/qmuparser/qmuparserbase.cpp
dismine 6a8869bc1b Made possible methods include. 
--HG--
branch : develop
2014-05-06 17:36:42 +03:00

2092 lines
71 KiB
C++
Raw Blame History

/***************************************************************************************************
**
** Original work Copyright (C) 2013 Ingo Berg
** Modified work Copyright 2014 Roman Telezhynskyi <dismine(at)gmail.com>
**
** Permission is hereby granted, free of charge, to any person obtaining a copy of this
** software and associated documentation files (the "Software"), to deal in the Software
** without restriction, including without limitation the rights to use, copy, modify,
** merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in all copies or
** substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
** NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
** DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
******************************************************************************************************/
#include "qmuparserbase.h"
#include <QTextStream>
#include <QtMath>
#ifdef QMUP_USE_OPENMP
#include <omp.h>
#endif
#include "qmuparsererror.h"
#include "qmuparsertokenreader.h"
using namespace std;
/**
* @file
* @brief This file contains the basic implementation of the muparser engine.
*/
namespace qmu
{
std::locale QmuParserBase::s_locale = std::locale(std::locale::classic(), new change_dec_sep<char_type>('.'));
bool QmuParserBase::g_DbgDumpCmdCode = false;
bool QmuParserBase::g_DbgDumpStack = false;
/**
* @brief Identifiers for built in binary operators.
*
* When defining custom binary operators with #AddOprt(...) make sure not to choose
* names conflicting with these definitions.
*/
const QStringList QmuParserBase::c_DefaultOprt = QStringList() << "<=" << ">=" << "!=" << "==" << "<" << ">"
<< "+" << "-" << "*" << "/" << "^" << "&&"
<< "||" << "=" << "(" << ")" << "?" << ":";
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor.
* @param a_szFormula the formula to interpret.
* @throw ParserException if a_szFormula is null.
*/
QmuParserBase::QmuParserBase()
:m_pParseFormula(&QmuParserBase::ParseString), m_vRPN(), m_vStringBuf(), m_vStringVarBuf(), m_pTokenReader(),
m_FunDef(), m_PostOprtDef(), m_InfixOprtDef(), m_OprtDef(), m_ConstDef(), m_StrVarDef(), m_VarDef(),
m_bBuiltInOp(true), m_sNameChars(), m_sOprtChars(), m_sInfixOprtChars(), m_nIfElseCounter(0), m_vStackBuffer(),
m_nFinalResultIdx(0)
{
InitTokenReader();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy constructor.
*
* Tha parser can be safely copy constructed but the bytecode is reset during copy construction.
*/
QmuParserBase::QmuParserBase(const QmuParserBase &a_Parser)
:m_pParseFormula(&QmuParserBase::ParseString), m_vRPN(), m_vStringBuf(), m_vStringVarBuf(), m_pTokenReader(),
m_FunDef(), m_PostOprtDef(), m_InfixOprtDef(), m_OprtDef(), m_ConstDef(), m_StrVarDef(), m_VarDef(),
m_bBuiltInOp(true), m_sNameChars(), m_sOprtChars(), m_sInfixOprtChars(), m_nIfElseCounter(0), m_vStackBuffer(),
m_nFinalResultIdx(0)
{
m_pTokenReader.reset(new token_reader_type(this));
Assign(a_Parser);
}
//---------------------------------------------------------------------------------------------------------------------
QmuParserBase::~QmuParserBase()
{}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Assignement operator.
*
* Implemented by calling Assign(a_Parser). Self assignement is suppressed.
* @param a_Parser Object to copy to this.
* @return *this
* @throw nothrow
*/
QmuParserBase& QmuParserBase::operator=(const QmuParserBase &a_Parser) Q_DECL_NOEXCEPT
{
Assign(a_Parser);
return *this;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy state of a parser object to this.
*
* Clears Variables and Functions of this parser.
* Copies the states of all internal variables.
* Resets parse function to string parse mode.
*
* @param a_Parser the source object.
*/
void QmuParserBase::Assign(const QmuParserBase &a_Parser)
{
if (&a_Parser==this)
{
return;
}
// Don't copy bytecode instead cause the parser to create new bytecode
// by resetting the parse function.
ReInit();
m_ConstDef = a_Parser.m_ConstDef; // Copy user define constants
m_VarDef = a_Parser.m_VarDef; // Copy user defined variables
m_bBuiltInOp = a_Parser.m_bBuiltInOp;
m_vStringBuf = a_Parser.m_vStringBuf;
m_vStackBuffer = a_Parser.m_vStackBuffer;
m_nFinalResultIdx = a_Parser.m_nFinalResultIdx;
m_StrVarDef = a_Parser.m_StrVarDef;
m_vStringVarBuf = a_Parser.m_vStringVarBuf;
m_nIfElseCounter = a_Parser.m_nIfElseCounter;
m_pTokenReader.reset(a_Parser.m_pTokenReader->Clone(this));
// Copy function and operator callbacks
m_FunDef = a_Parser.m_FunDef; // Copy function definitions
m_PostOprtDef = a_Parser.m_PostOprtDef; // post value unary operators
m_InfixOprtDef = a_Parser.m_InfixOprtDef; // unary operators for infix notation
m_OprtDef = a_Parser.m_OprtDef; // binary operators
m_sNameChars = a_Parser.m_sNameChars;
m_sOprtChars = a_Parser.m_sOprtChars;
m_sInfixOprtChars = a_Parser.m_sInfixOprtChars;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set the decimal separator.
* @param cDecSep Decimal separator as a character value.
* @sa SetThousandsSep
*
* By default muparser uses the "C" locale. The decimal separator of this
* locale is overwritten by the one provided here.
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::SetDecSep(char_type cDecSep)
{
char_type cThousandsSep = std::use_facet< change_dec_sep<char_type> >(s_locale).thousands_sep();
s_locale = std::locale(std::locale("C"), new change_dec_sep<char_type>(cDecSep, cThousandsSep));
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Sets the thousands operator.
* @param cThousandsSep The thousands separator as a character
* @sa SetDecSep
*
* By default muparser uses the "C" locale. The thousands separator of this
* locale is overwritten by the one provided here.
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::SetThousandsSep(char_type cThousandsSep)
{
char_type cDecSep = std::use_facet< change_dec_sep<char_type> >(s_locale).decimal_point();
s_locale = std::locale(std::locale("C"), new change_dec_sep<char_type>(cDecSep, cThousandsSep));
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Resets the locale.
*
* The default locale used "." as decimal separator, no thousands separator and "," as function argument separator.
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::ResetLocale()
{
s_locale = std::locale(std::locale("C"), new change_dec_sep<char_type>('.'));
SetArgSep(',');
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Reset parser to string parsing mode and clear internal buffers.
*
* Clear bytecode, reset the token reader.
* @throw nothrow
*/
void QmuParserBase::ReInit() const Q_DECL_NOEXCEPT
{
m_pParseFormula = &QmuParserBase::ParseString;
m_vStringBuf.clear();
m_vRPN.clear();
m_pTokenReader->ReInit();
m_nIfElseCounter = 0;
}
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::OnDetectVar(const QString &pExpr, int &nStart, int &nEnd)
{
Q_UNUSED(pExpr);
Q_UNUSED(nStart);
Q_UNUSED(nEnd);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Returns the version of muparser.
* @param eInfo A flag indicating whether the full version info should be returned or not.
*
* Format is as follows: "MAJOR.MINOR (COMPILER_FLAGS)" The COMPILER_FLAGS are returned only if eInfo==pviFULL.
*/
// cppcheck-suppress unusedFunction
QString QmuParserBase::GetVersion(EParserVersionInfo eInfo)
{
QString versionInfo;
QTextStream ss(&versionInfo);
ss << QMUP_VERSION;
if (eInfo==pviFULL)
{
ss << " (" << QMUP_VERSION_DATE;
ss << "; " << sizeof(void*)*8 << "BIT";
#ifdef _DEBUG
ss << "; DEBUG";
#else
ss << "; RELEASE";
#endif
#ifdef _UNICODE
ss << "; UNICODE";
#else
#ifdef _MBCS
ss << "; MBCS";
#else
ss << "; ASCII";
#endif
#endif
#ifdef QMUP_USE_OPENMP
ss << "; OPENMP";
//#else
// ss << "; NO_OPENMP";
#endif
#if defined(MUP_MATH_EXCEPTIONS)
ss << "; MATHEXC";
//#else
// ss << "; NO_MATHEXC";
#endif
ss << ")";
}
return versionInfo;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a function or operator callback to the parser.
*/
void QmuParserBase::AddCallback(const QString &a_strName, const QmuParserCallback &a_Callback,
funmap_type &a_Storage, const QString &a_szCharSet )
{
if (a_Callback.GetAddr()==0)
{
Error(ecINVALID_FUN_PTR);
}
const funmap_type *pFunMap = &a_Storage;
// Check for conflicting operator or function names
if ( pFunMap!=&m_FunDef && m_FunDef.find(a_strName)!=m_FunDef.end() )
{
Error(ecNAME_CONFLICT, -1, a_strName);
}
if ( pFunMap!=&m_PostOprtDef && m_PostOprtDef.find(a_strName)!=m_PostOprtDef.end() )
{
Error(ecNAME_CONFLICT, -1, a_strName);
}
if ( pFunMap!=&m_InfixOprtDef && pFunMap!=&m_OprtDef && m_InfixOprtDef.find(a_strName)!=m_InfixOprtDef.end() )
{
Error(ecNAME_CONFLICT, -1, a_strName);
}
if ( pFunMap!=&m_InfixOprtDef && pFunMap!=&m_OprtDef && m_OprtDef.find(a_strName)!=m_OprtDef.end() )
{
Error(ecNAME_CONFLICT, -1, a_strName);
}
CheckOprt(a_strName, a_Callback, a_szCharSet);
a_Storage[a_strName] = a_Callback;
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a name contains invalid characters.
*
* @throw ParserException if the name contains invalid charakters.
*/
void QmuParserBase::CheckOprt(const QString &a_sName, const QmuParserCallback &a_Callback,
const QString &a_szCharSet) const
{
#if defined(_UNICODE)
const std::wstring a_sNameStd = a_sName.toStdWString();
const std::wstring a_szCharSetStd = a_szCharSet.toStdWString();
#else
const std::string a_sNameStd = a_sName.toStdString();
const std::string a_szCharSetStd = a_szCharSet.toStdString();
#endif
if ( a_sNameStd.length() == false || (a_sNameStd.find_first_not_of(a_szCharSetStd)!=string_type::npos) ||
(a_sNameStd.at(0)>='0' && a_sNameStd.at(0)<='9'))
{
switch (a_Callback.GetCode())
{
case cmOPRT_POSTFIX:
Error(ecINVALID_POSTFIX_IDENT, -1, a_sName);
break;
case cmOPRT_INFIX:
Error(ecINVALID_INFIX_IDENT, -1, a_sName);
break;
case cmLE:
case cmGE:
case cmNEQ:
case cmEQ:
case cmLT:
case cmGT:
case cmADD:
case cmSUB:
case cmMUL:
case cmDIV:
case cmPOW:
case cmLAND:
case cmLOR:
case cmASSIGN:
case cmBO:
case cmBC:
case cmIF:
case cmELSE:
case cmENDIF:
case cmARG_SEP:
case cmVAR:
case cmVAL:
case cmVARPOW2:
case cmVARPOW3:
case cmVARPOW4:
case cmVARMUL:
case cmPOW2:
case cmFUNC:
case cmFUNC_STR:
case cmFUNC_BULK:
case cmSTRING:
case cmOPRT_BIN:
case cmEND:
case cmUNKNOWN:
default:
Error(ecINVALID_NAME, -1, a_sName);
break;
}
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a name contains invalid characters.
*
* @throw ParserException if the name contains invalid charakters.
*/
void QmuParserBase::CheckName(const QString &a_sName, const QString &a_szCharSet) const
{
#if defined(_UNICODE)
std::wstring a_sNameStd = a_sName.toStdWString();
std::wstring a_szCharSetStd = a_szCharSet.toStdWString();
#else
std::string a_sNameStd = a_sName.toStdString();
std::string a_szCharSetStd = a_szCharSet.toStdString();
#endif
if ( a_sNameStd.length() == false || (a_sNameStd.find_first_not_of(a_szCharSetStd)!=string_type::npos) ||
(a_sNameStd[0]>='0' && a_sNameStd[0]<='9'))
{
Error(ecINVALID_NAME);
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set the formula.
* @param a_strFormula Formula as string_type
* @throw ParserException in case of syntax errors.
*
* Triggers first time calculation thus the creation of the bytecode and scanning of used variables.
*/
void QmuParserBase::SetExpr(const QString &a_sExpr)
{
// Check locale compatibility
std::locale loc;
if (m_pTokenReader->GetArgSep()==std::use_facet<numpunct<char_type> >(loc).decimal_point())
{
Error(ecLOCALE);
}
// <ibg> 20060222: Bugfix for Borland-Kylix:
// adding a space to the expression will keep Borlands KYLIX from going wild
// when calling tellg on a stringstream created from the expression after
// reading a value at the end of an expression. (qmu::QmuParser::IsVal function)
// (tellg returns -1 otherwise causing the parser to ignore the value)
QString sBuf(a_sExpr + " " );
m_pTokenReader->SetFormula(sBuf);
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Virtual function that defines the characters allowed in name identifiers.
* @sa #ValidOprtChars, #ValidPrefixOprtChars
*/
const QString& QmuParserBase::ValidNameChars() const
{
assert(m_sNameChars.size());
return m_sNameChars;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Virtual function that defines the characters allowed in operator definitions.
* @sa #ValidNameChars, #ValidPrefixOprtChars
*/
const QString &QmuParserBase::ValidOprtChars() const
{
assert(m_sOprtChars.size());
return m_sOprtChars;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Virtual function that defines the characters allowed in infix operator definitions.
* @sa #ValidNameChars, #ValidOprtChars
*/
const QString &QmuParserBase::ValidInfixOprtChars() const
{
assert(m_sInfixOprtChars.size());
return m_sInfixOprtChars;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined operator.
* @post Will reset the Parser to string parsing mode.
*/
void QmuParserBase::DefinePostfixOprt(const QString &a_sName, fun_type1 a_pFun, bool a_bAllowOpt)
{
AddCallback(a_sName, QmuParserCallback(a_pFun, a_bAllowOpt, prPOSTFIX, cmOPRT_POSTFIX), m_PostOprtDef,
ValidOprtChars() );
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize user defined functions.
*
* Calls the virtual functions InitFun(), InitConst() and InitOprt().
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::Init()
{
InitCharSets();
InitFun();
InitConst();
InitOprt();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined operator.
* @post Will reset the Parser to string parsing mode.
* @param [in] a_sName operator Identifier
* @param [in] a_pFun Operator callback function
* @param [in] a_iPrec Operator Precedence (default=prSIGN)
* @param [in] a_bAllowOpt True if operator is volatile (default=false)
* @sa EPrec
*/
void QmuParserBase::DefineInfixOprt(const QString &a_sName, fun_type1 a_pFun, int a_iPrec, bool a_bAllowOpt)
{
AddCallback(a_sName, QmuParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_INFIX), m_InfixOprtDef,
ValidInfixOprtChars() );
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define a binary operator.
* @param [in] a_sName The identifier of the operator.
* @param [in] a_pFun Pointer to the callback function.
* @param [in] a_iPrec Precedence of the operator.
* @param [in] a_eAssociativity The associativity of the operator.
* @param [in] a_bAllowOpt If this is true the operator may be optimized away.
*
* Adds a new Binary operator the the parser instance.
*/
void QmuParserBase::DefineOprt( const QString &a_sName, fun_type2 a_pFun, unsigned a_iPrec,
EOprtAssociativity a_eAssociativity, bool a_bAllowOpt )
{
// Check for conflicts with built in operator names
for (int i=0; m_bBuiltInOp && i<cmENDIF; ++i)
{
if (a_sName == c_DefaultOprt.at(i))
{
Error(ecBUILTIN_OVERLOAD, -1, a_sName);
}
}
AddCallback(a_sName, QmuParserCallback(a_pFun, a_bAllowOpt, a_iPrec, a_eAssociativity), m_OprtDef,
ValidOprtChars() );
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define a new string constant.
* @param [in] a_strName The name of the constant.
* @param [in] a_strVal the value of the constant.
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::DefineStrConst(const QString &a_strName, const QString &a_strVal)
{
// Test if a constant with that names already exists
if (m_StrVarDef.find(a_strName)!=m_StrVarDef.end())
{
Error(ecNAME_CONFLICT);
}
CheckName(a_strName, ValidNameChars());
m_vStringVarBuf.push_back(a_strVal); // Store variable string in internal buffer
m_StrVarDef[a_strName] = m_vStringBuf.size(); // bind buffer index to variable name
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined variable.
* @param [in] a_sName the variable name
* @param [in] a_pVar A pointer to the variable vaule.
* @post Will reset the Parser to string parsing mode.
* @throw ParserException in case the name contains invalid signs or a_pVar is NULL.
*/
void QmuParserBase::DefineVar(const QString &a_sName, qreal *a_pVar)
{
if (a_pVar==0)
{
Error(ecINVALID_VAR_PTR);
}
// Test if a constant with that names already exists
if (m_ConstDef.find(a_sName)!=m_ConstDef.end())
{
Error(ecNAME_CONFLICT);
}
CheckName(a_sName, ValidNameChars());
m_VarDef[a_sName] = a_pVar;
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined constant.
* @param [in] a_sName The name of the constant.
* @param [in] a_fVal the value of the constant.
* @post Will reset the Parser to string parsing mode.
* @throw ParserException in case the name contains invalid signs.
*/
void QmuParserBase::DefineConst(const QString &a_sName, qreal a_fVal)
{
CheckName(a_sName, ValidNameChars());
m_ConstDef[a_sName] = a_fVal;
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get operator priority.
* @throw ParserException if a_Oprt is no operator code
*/
int QmuParserBase::GetOprtPrecedence(const token_type &a_Tok) const
{
switch (a_Tok.GetCode())
{
// built in operators
case cmEND:
return -5;
case cmARG_SEP:
return -4;
case cmASSIGN:
return -1;
case cmELSE:
case cmIF:
return 0;
case cmLAND:
return prLAND;
case cmLOR:
return prLOR;
case cmLT:
case cmGT:
case cmLE:
case cmGE:
case cmNEQ:
case cmEQ:
return prCMP;
case cmADD:
case cmSUB:
return prADD_SUB;
case cmMUL:
case cmDIV:
return prMUL_DIV;
case cmPOW:
return prPOW;
// user defined binary operators
case cmOPRT_INFIX:
case cmOPRT_BIN:
return a_Tok.GetPri();
case cmBO:
case cmBC:
case cmENDIF:
case cmVAR:
case cmVAL:
case cmVARPOW2:
case cmVARPOW3:
case cmVARPOW4:
case cmVARMUL:
case cmPOW2:
case cmFUNC:
case cmFUNC_STR:
case cmFUNC_BULK:
case cmSTRING:
case cmOPRT_POSTFIX:
case cmUNKNOWN:
default:
Error(ecINTERNAL_ERROR, 5);
return 999;
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get operator priority.
* @throw ParserException if a_Oprt is no operator code
*/
EOprtAssociativity QmuParserBase::GetOprtAssociativity(const token_type &a_Tok) const
{
switch (a_Tok.GetCode())
{
case cmASSIGN:
case cmLAND:
case cmLOR:
case cmLT:
case cmGT:
case cmLE:
case cmGE:
case cmNEQ:
case cmEQ:
case cmADD:
case cmSUB:
case cmMUL:
case cmDIV:
return oaLEFT;
case cmPOW:
return oaRIGHT;
case cmOPRT_BIN:
return a_Tok.GetAssociativity();
case cmBO:
case cmBC:
case cmIF:
case cmELSE:
case cmENDIF:
case cmARG_SEP:
case cmVAR:
case cmVAL:
case cmVARPOW2:
case cmVARPOW3:
case cmVARPOW4:
case cmVARMUL:
case cmPOW2:
case cmFUNC:
case cmFUNC_STR:
case cmFUNC_BULK:
case cmSTRING:
case cmOPRT_POSTFIX:
case cmOPRT_INFIX:
case cmEND:
case cmUNKNOWN:
default:
return oaNONE;
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return a map containing the used variables only.
*/
const varmap_type& QmuParserBase::GetUsedVar() const
{
try
{
m_pTokenReader->IgnoreUndefVar(true);
CreateRPN(); // try to create bytecode, but don't use it for any further calculations since it
// may contain references to nonexisting variables.
m_pParseFormula = &QmuParserBase::ParseString;
m_pTokenReader->IgnoreUndefVar(false);
}
catch (const QmuParserError &e)
{
// Make sure to stay in string parse mode, dont call ReInit()
// because it deletes the array with the used variables
m_pParseFormula = &QmuParserBase::ParseString;
m_pTokenReader->IgnoreUndefVar(false);
throw;
}
return m_pTokenReader->GetUsedVar();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Execute a function that takes a single string argument.
* @param a_FunTok Function token.
* @throw QmuParserError If the function token is not a string function
*/
QmuParserBase::token_type QmuParserBase::ApplyStrFunc(const token_type &a_FunTok,
const QVector<token_type> &a_vArg) const
{
if (a_vArg.back().GetCode()!=cmSTRING)
{
Error(ecSTRING_EXPECTED, m_pTokenReader->GetPos(), a_FunTok.GetAsString());
}
token_type valTok;
generic_fun_type pFunc = a_FunTok.GetFuncAddr();
assert(pFunc);
try
{
// Check function arguments; write dummy value into valtok to represent the result
switch (a_FunTok.GetArgCount())
{
case 0:
valTok.SetVal(1);
a_vArg[0].GetAsString();
break;
case 1:
valTok.SetVal(1);
a_vArg[1].GetAsString();
a_vArg[0].GetVal();
break;
case 2:
valTok.SetVal(1);
a_vArg[2].GetAsString();
a_vArg[1].GetVal();
a_vArg[0].GetVal();
break;
default:
Error(ecINTERNAL_ERROR);
break;
}
}
catch (QmuParserError& )
{
Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), a_FunTok.GetAsString());
}
// string functions won't be optimized
m_vRPN.AddStrFun(pFunc, a_FunTok.GetArgCount(), a_vArg.back().GetIdx());
// Push dummy value representing the function result to the stack
return valTok;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Apply a function token.
* @param iArgCount Number of Arguments actually gathered used only for multiarg functions.
* @post The result is pushed to the value stack
* @post The function token is removed from the stack
* @throw QmuParserError if Argument count does not mach function requirements.
*/
void QmuParserBase::ApplyFunc( QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal, int a_iArgCount) const
{
assert(m_pTokenReader.get());
// Operator stack empty or does not contain tokens with callback functions
if (a_stOpt.empty() || a_stOpt.top().GetFuncAddr()==0 )
{
return;
}
token_type funTok = a_stOpt.pop();
assert(funTok.GetFuncAddr());
// Binary operators must rely on their internal operator number
// since counting of operators relies on commas for function arguments
// binary operators do not have commas in their expression
int iArgCount = (funTok.GetCode()==cmOPRT_BIN) ? funTok.GetArgCount() : a_iArgCount;
// determine how many parameters the function needs. To remember iArgCount includes the
// string parameter whilst GetArgCount() counts only numeric parameters.
int iArgRequired = funTok.GetArgCount() + ((funTok.GetType()==tpSTR) ? 1 : 0);
// Thats the number of numerical parameters
int iArgNumerical = iArgCount - ((funTok.GetType()==tpSTR) ? 1 : 0);
if (funTok.GetCode()==cmFUNC_STR && iArgCount-iArgNumerical>1)
{
Error(ecINTERNAL_ERROR);
}
if (funTok.GetArgCount()>=0 && iArgCount>iArgRequired)
{
Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos()-1, funTok.GetAsString());
}
if (funTok.GetCode()!=cmOPRT_BIN && iArgCount<iArgRequired )
{
Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos()-1, funTok.GetAsString());
}
if (funTok.GetCode()==cmFUNC_STR && iArgCount>iArgRequired )
{
Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos()-1, funTok.GetAsString());
}
// Collect the numeric function arguments from the value stack and store them
// in a vector
QVector<token_type> stArg;
for (int i=0; i<iArgNumerical; ++i)
{
stArg.push_back( a_stVal.pop() );
if ( stArg.back().GetType()==tpSTR && funTok.GetType()!=tpSTR )
{
Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString());
}
}
switch (funTok.GetCode())
{
case cmFUNC_STR:
stArg.push_back(a_stVal.pop());
if ( stArg.back().GetType()==tpSTR && funTok.GetType()!=tpSTR )
{
Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString());
}
ApplyStrFunc(funTok, stArg);
break;
case cmFUNC_BULK:
m_vRPN.AddBulkFun(funTok.GetFuncAddr(), stArg.size());
break;
case cmOPRT_BIN:
case cmOPRT_POSTFIX:
case cmOPRT_INFIX:
case cmFUNC:
if (funTok.GetArgCount()==-1 && iArgCount==0)
{
Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos(), funTok.GetAsString());
}
m_vRPN.AddFun(funTok.GetFuncAddr(), (funTok.GetArgCount()==-1) ? -iArgNumerical : iArgNumerical);
break;
case cmLE:
Q_UNREACHABLE();
break;
case cmGE:
Q_UNREACHABLE();
break;
case cmNEQ:
Q_UNREACHABLE();
break;
case cmEQ:
Q_UNREACHABLE();
break;
case cmLT:
Q_UNREACHABLE();
break;
case cmGT:
Q_UNREACHABLE();
break;
case cmADD:
Q_UNREACHABLE();
break;
case cmSUB:
Q_UNREACHABLE();
break;
case cmMUL:
Q_UNREACHABLE();
break;
case cmDIV:
Q_UNREACHABLE();
break;
case cmPOW:
Q_UNREACHABLE();
break;
case cmLAND:
Q_UNREACHABLE();
break;
case cmLOR:
Q_UNREACHABLE();
break;
case cmASSIGN:
Q_UNREACHABLE();
break;
case cmBO:
Q_UNREACHABLE();
break;
case cmBC:
Q_UNREACHABLE();
break;
case cmIF:
Q_UNREACHABLE();
break;
case cmELSE:
Q_UNREACHABLE();
break;
case cmENDIF:
Q_UNREACHABLE();
break;
case cmARG_SEP:
Q_UNREACHABLE();
break;
case cmVAR:
Q_UNREACHABLE();
break;
case cmVAL:
Q_UNREACHABLE();
break;
case cmVARPOW2:
Q_UNREACHABLE();
break;
case cmVARPOW3:
Q_UNREACHABLE();
break;
case cmVARPOW4:
Q_UNREACHABLE();
break;
case cmVARMUL:
Q_UNREACHABLE();
break;
case cmPOW2:
Q_UNREACHABLE();
break;
case cmSTRING:
Q_UNREACHABLE();
break;
case cmEND:
Q_UNREACHABLE();
break;
case cmUNKNOWN:
Q_UNREACHABLE();
break;
default:
break;
}
// Push dummy value representing the function result to the stack
token_type token;
token.SetVal(1);
a_stVal.push(token);
}
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::ApplyIfElse(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const
{
// Check if there is an if Else clause to be calculated
while (a_stOpt.size() && a_stOpt.top().GetCode()==cmELSE)
{
token_type opElse = a_stOpt.pop();
Q_ASSERT(a_stOpt.size()>0);
// Take the value associated with the else branch from the value stack
token_type vVal2 = a_stVal.pop();
Q_ASSERT(a_stOpt.size()>0);
Q_ASSERT(a_stVal.size()>=2);
// it then else is a ternary operator Pop all three values from the value s
// tack and just return the right value
token_type vVal1 = a_stVal.pop();
token_type vExpr = a_stVal.pop();
a_stVal.push( (qFuzzyCompare(vExpr.GetVal()+1, 1+0)==false) ? vVal1 : vVal2);
token_type opIf = a_stOpt.pop();
Q_ASSERT(opElse.GetCode()==cmELSE);
Q_ASSERT(opIf.GetCode()==cmIF);
m_vRPN.AddIfElse(cmENDIF);
} // while pending if-else-clause found
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Performs the necessary steps to write code for the execution of binary operators into the bytecode.
*/
void QmuParserBase::ApplyBinOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const
{
// is it a user defined binary operator?
if (a_stOpt.top().GetCode()==cmOPRT_BIN)
{
ApplyFunc(a_stOpt, a_stVal, 2);
}
else
{
Q_ASSERT(a_stVal.size()>=2);
token_type valTok1 = a_stVal.pop(),
valTok2 = a_stVal.pop(),
optTok = a_stOpt.pop(),
resTok;
if ( valTok1.GetType()!=valTok2.GetType() || (valTok1.GetType()==tpSTR && valTok2.GetType()==tpSTR) )
{
Error(ecOPRT_TYPE_CONFLICT, m_pTokenReader->GetPos(), optTok.GetAsString());
}
if (optTok.GetCode()==cmASSIGN)
{
if (valTok2.GetCode()!=cmVAR)
{
Error(ecUNEXPECTED_OPERATOR, -1, "=");
}
m_vRPN.AddAssignOp(valTok2.GetVar());
}
else
{
m_vRPN.AddOp(optTok.GetCode());
}
resTok.SetVal(1);
a_stVal.push(resTok);
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Apply a binary operator.
* @param a_stOpt The operator stack
* @param a_stVal The value stack
*/
void QmuParserBase::ApplyRemainingOprt(QStack<token_type> &stOpt, QStack<token_type> &stVal) const
{
while (stOpt.size() && stOpt.top().GetCode() != cmBO && stOpt.top().GetCode() != cmIF)
{
token_type tok = stOpt.top();
switch (tok.GetCode())
{
case cmOPRT_INFIX:
case cmOPRT_BIN:
case cmLE:
case cmGE:
case cmNEQ:
case cmEQ:
case cmLT:
case cmGT:
case cmADD:
case cmSUB:
case cmMUL:
case cmDIV:
case cmPOW:
case cmLAND:
case cmLOR:
case cmASSIGN:
if (stOpt.top().GetCode()==cmOPRT_INFIX)
{
ApplyFunc(stOpt, stVal, 1);
}
else
{
ApplyBinOprt(stOpt, stVal);
}
break;
case cmELSE:
ApplyIfElse(stOpt, stVal);
break;
case cmBO:
case cmBC:
case cmIF:
case cmENDIF:
case cmARG_SEP:
case cmVAR:
case cmVAL:
case cmVARPOW2:
case cmVARPOW3:
case cmVARPOW4:
case cmVARMUL:
case cmPOW2:
case cmFUNC:
case cmFUNC_STR:
case cmFUNC_BULK:
case cmSTRING:
case cmOPRT_POSTFIX:
case cmEND:
case cmUNKNOWN:
default:
Error(ecINTERNAL_ERROR);
break;
}
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Parse the command code.
* @sa ParseString(...)
*
* Command code contains precalculated stack positions of the values and the associated operators. The Stack is
* filled beginning from index one the value at index zero is not used at all.
*/
qreal QmuParserBase::ParseCmdCode() const
{
return ParseCmdCodeBulk(0, 0);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Evaluate the RPN.
* @param nOffset The offset added to variable addresses (for bulk mode)
* @param nThreadID OpenMP Thread id of the calling thread
*/
qreal QmuParserBase::ParseCmdCodeBulk(int nOffset, int nThreadID) const
{
assert(nThreadID<=s_MaxNumOpenMPThreads);
// Note: The check for nOffset==0 and nThreadID here is not necessary but
// brings a minor performance gain when not in bulk mode.
qreal *Stack = ((nOffset==0) && (nThreadID==0)) ? &m_vStackBuffer[0] : &m_vStackBuffer[nThreadID *
(m_vStackBuffer.size() / s_MaxNumOpenMPThreads)];
qreal buf;
int sidx(0);
for (const SToken *pTok = m_vRPN.GetBase(); pTok->Cmd!=cmEND ; ++pTok)
{
switch (pTok->Cmd)
{
// built in binary operators
case cmLE:
--sidx;
Stack[sidx] = Stack[sidx] <= Stack[sidx+1];
continue;
case cmGE:
--sidx;
Stack[sidx] = Stack[sidx] >= Stack[sidx+1];
continue;
case cmNEQ:
--sidx;
Stack[sidx] = (qFuzzyCompare(Stack[sidx], Stack[sidx+1])==false);
continue;
case cmEQ:
--sidx;
Stack[sidx] = qFuzzyCompare(Stack[sidx], Stack[sidx+1]);
continue;
case cmLT:
--sidx;
Stack[sidx] = Stack[sidx] < Stack[sidx+1];
continue;
case cmGT:
--sidx;
Stack[sidx] = Stack[sidx] > Stack[sidx+1];
continue;
case cmADD:
--sidx;
Stack[sidx] += Stack[1+sidx];
continue;
case cmSUB:
--sidx;
Stack[sidx] -= Stack[1+sidx];
continue;
case cmMUL:
--sidx;
Stack[sidx] *= Stack[1+sidx];
continue;
case cmDIV:
--sidx;
#if defined(MUP_MATH_EXCEPTIONS)
if (Stack[1+sidx]==0)
{
Error(ecDIV_BY_ZERO);
}
#endif
Stack[sidx] /= Stack[1+sidx];
continue;
case cmPOW:
--sidx;
Stack[sidx] = qPow(Stack[sidx], Stack[1+sidx]);
continue;
case cmLAND:
--sidx;
#ifdef Q_CC_GNU
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
Stack[sidx] = Stack[sidx] && Stack[sidx+1];
#ifdef Q_CC_GNU
#pragma GCC diagnostic pop
#endif
continue;
case cmLOR:
--sidx;
#ifdef Q_CC_GNU
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
Stack[sidx] = Stack[sidx] || Stack[sidx+1];
#ifdef Q_CC_GNU
#pragma GCC diagnostic pop
#endif
continue;
case cmASSIGN:
--sidx;
Stack[sidx] = *pTok->Oprt.ptr = Stack[sidx+1];
continue;
case cmIF:
if (qFuzzyCompare(Stack[sidx--]+1, 1+0))
{
pTok += pTok->Oprt.offset;
}
continue;
case cmELSE:
pTok += pTok->Oprt.offset;
continue;
case cmENDIF:
continue;
// value and variable tokens
case cmVAR:
Stack[++sidx] = *(pTok->Val.ptr + nOffset);
continue;
case cmVAL:
Stack[++sidx] = pTok->Val.data2;
continue;
case cmVARPOW2:
buf = *(pTok->Val.ptr + nOffset);
Stack[++sidx] = buf*buf;
continue;
case cmVARPOW3:
buf = *(pTok->Val.ptr + nOffset);
Stack[++sidx] = buf*buf*buf;
continue;
case cmVARPOW4:
buf = *(pTok->Val.ptr + nOffset);
Stack[++sidx] = buf*buf*buf*buf;
continue;
case cmVARMUL:
Stack[++sidx] = *(pTok->Val.ptr + nOffset) * pTok->Val.data + pTok->Val.data2;
continue;
// Next is treatment of numeric functions
case cmFUNC:
{
int iArgCount = pTok->Fun.argc;
// switch according to argument count
switch (iArgCount)
{
case 0:
sidx += 1;
Stack[sidx] = (*reinterpret_cast<fun_type0>(pTok->Fun.ptr))();
continue;
case 1:
Stack[sidx] = (*reinterpret_cast<fun_type1>(pTok->Fun.ptr))(Stack[sidx]);
continue;
case 2:
sidx -= 1;
Stack[sidx] = (*reinterpret_cast<fun_type2>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1]);
continue;
case 3:
sidx -= 2;
Stack[sidx] = (*reinterpret_cast<fun_type3>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2]);
continue;
case 4:
sidx -= 3;
Stack[sidx] = (*reinterpret_cast<fun_type4>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3]);
continue;
case 5:
sidx -= 4;
Stack[sidx] = (*reinterpret_cast<fun_type5>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3], Stack[sidx+4]);
continue;
case 6:
sidx -= 5;
Stack[sidx] = (*reinterpret_cast<fun_type6>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3], Stack[sidx+4], Stack[sidx+5]);
continue;
case 7:
sidx -= 6;
Stack[sidx] = (*reinterpret_cast<fun_type7>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3], Stack[sidx+4], Stack[sidx+5], Stack[sidx+6]);
continue;
case 8:
sidx -= 7;
Stack[sidx] = (*reinterpret_cast<fun_type8>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3], Stack[sidx+4], Stack[sidx+5], Stack[sidx+6],
Stack[sidx+7]);
continue;
case 9:
sidx -= 8;
Stack[sidx] = (*reinterpret_cast<fun_type9>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3], Stack[sidx+4], Stack[sidx+5], Stack[sidx+6],
Stack[sidx+7], Stack[sidx+8]);
continue;
case 10:
sidx -= 9;
Stack[sidx] = (*reinterpret_cast<fun_type10>(pTok->Fun.ptr))(Stack[sidx], Stack[sidx+1],
Stack[sidx+2], Stack[sidx+3], Stack[sidx+4], Stack[sidx+5], Stack[sidx+6],
Stack[sidx+7], Stack[sidx+8], Stack[sidx+9]);
continue;
default:
if (iArgCount>0) // function with variable arguments store the number as a negative value
{
Error(ecINTERNAL_ERROR, 1);
}
sidx -= -iArgCount - 1;
Stack[sidx] =(*reinterpret_cast<multfun_type>(pTok->Fun.ptr))(&Stack[sidx], -iArgCount);
continue;
}
}
// Next is treatment of string functions
case cmFUNC_STR:
{
sidx -= pTok->Fun.argc -1;
// The index of the string argument in the string table
int iIdxStack = pTok->Fun.idx;
Q_ASSERT( iIdxStack>=0 && iIdxStack<m_vStringBuf.size() );
switch (pTok->Fun.argc) // switch according to argument count
{
case 0:
Stack[sidx] = (*reinterpret_cast<strfun_type1>(pTok->Fun.ptr))(m_vStringBuf.at(iIdxStack));
continue;
case 1:
Stack[sidx] = (*reinterpret_cast<strfun_type2>(pTok->Fun.ptr))(m_vStringBuf.at(iIdxStack),
Stack[sidx]);
continue;
case 2:
Stack[sidx] = (*reinterpret_cast<strfun_type3>(pTok->Fun.ptr))(m_vStringBuf.at(iIdxStack),
Stack[sidx], Stack[sidx+1]);
continue;
default:
break;
}
continue;
}
case cmFUNC_BULK:
{
int iArgCount = pTok->Fun.argc;
// switch according to argument count
switch (iArgCount)
{
case 0:
sidx += 1;
Stack[sidx] = (*reinterpret_cast<bulkfun_type0>(pTok->Fun.ptr))(nOffset, nThreadID);
continue;
case 1:
Stack[sidx] = (*reinterpret_cast<bulkfun_type1>(pTok->Fun.ptr))(nOffset, nThreadID,
Stack[sidx]);
continue;
case 2:
sidx -= 1;
Stack[sidx] = (*reinterpret_cast<bulkfun_type2>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1]);
continue;
case 3:
sidx -= 2;
Stack[sidx] = (*reinterpret_cast<bulkfun_type3>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2]);
continue;
case 4:
sidx -= 3;
Stack[sidx] = (*reinterpret_cast<bulkfun_type4>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2], Stack[sidx+3]);
continue;
case 5:
sidx -= 4;
Stack[sidx] = (*reinterpret_cast<bulkfun_type5>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2], Stack[sidx+3],
Stack[sidx+4]);
continue;
case 6:
sidx -= 5;
Stack[sidx] = (*reinterpret_cast<bulkfun_type6>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2],
Stack[sidx+3], Stack[sidx+4], Stack[sidx+5]);
continue;
case 7:
sidx -= 6;
Stack[sidx] = (*reinterpret_cast<bulkfun_type7>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2], Stack[sidx+3],
Stack[sidx+4], Stack[sidx+5], Stack[sidx+6]);
continue;
case 8:
sidx -= 7;
Stack[sidx] = (*reinterpret_cast<bulkfun_type8>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2], Stack[sidx+3],
Stack[sidx+4], Stack[sidx+5], Stack[sidx+6], Stack[sidx+7]);
continue;
case 9:
sidx -= 8;
Stack[sidx] = (*reinterpret_cast<bulkfun_type9>(pTok->Fun.ptr))(nOffset, nThreadID, Stack[sidx],
Stack[sidx+1], Stack[sidx+2], Stack[sidx+3],
Stack[sidx+4], Stack[sidx+5], Stack[sidx+6], Stack[sidx+7], Stack[sidx+8]);
continue;
case 10:
sidx -= 9;
Stack[sidx] = (*reinterpret_cast<bulkfun_type10>(pTok->Fun.ptr))(nOffset, nThreadID,
Stack[sidx],
Stack[sidx+1], Stack[sidx+2], Stack[sidx+3],
Stack[sidx+4], Stack[sidx+5], Stack[sidx+6], Stack[sidx+7], Stack[sidx+8],
Stack[sidx+9]);
continue;
default:
Error(ecINTERNAL_ERROR, 2);
continue;
}
}
case cmSTRING:
case cmOPRT_BIN:
case cmOPRT_POSTFIX:
case cmOPRT_INFIX:
// Q_ASSERT(INVALID_CODE_IN_BYTECODE);
// continue;
case cmEND:
// return Stack[m_nFinalResultIdx];
case cmPOW2:
case cmUNKNOWN:
case cmBO: // unused, listed for compiler optimization purposes
case cmBC:
// Q_ASSERT(INVALID_CODE_IN_BYTECODE);
// continue;
case cmARG_SEP:
// Q_ASSERT(INVALID_CODE_IN_BYTECODE);
// continue;
default:
Error(ecINTERNAL_ERROR, 3);
return 0;
} // switch CmdCode
} // for all bytecode tokens
return Stack[m_nFinalResultIdx];
}
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::CreateRPN() const
{
if (m_pTokenReader->GetExpr().length() == false)
{
Error(ecUNEXPECTED_EOF, 0);
}
QStack<token_type> stOpt, stVal;
QStack<int> stArgCount;
token_type opta, opt; // for storing operators
//token_type val, tval; // for storing value
//string_type strBuf; // buffer for string function arguments
ReInit();
// The outermost counter counts the number of seperated items
// such as in "a=10,b=20,c=c+a"
stArgCount.push(1);
for (;;)
{
opt = m_pTokenReader->ReadNextToken();
switch (opt.GetCode())
{
//
// Next three are different kind of value entries
//
case cmSTRING:
opt.SetIdx(m_vStringBuf.size()); // Assign buffer index to token
stVal.push(opt);
m_vStringBuf.push_back(opt.GetAsString()); // Store string in internal buffer
break;
case cmVAR:
stVal.push(opt);
m_vRPN.AddVar( static_cast<qreal*>(opt.GetVar()) );
break;
case cmVAL:
stVal.push(opt);
m_vRPN.AddVal( opt.GetVal() );
break;
case cmELSE:
m_nIfElseCounter--;
if (m_nIfElseCounter<0)
{
Error(ecMISPLACED_COLON, m_pTokenReader->GetPos());
}
ApplyRemainingOprt(stOpt, stVal);
m_vRPN.AddIfElse(cmELSE);
stOpt.push(opt);
break;
case cmARG_SEP:
if (stArgCount.empty())
{
Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos());
}
++stArgCount.top();
// fallthrough intentional (no break!)
case cmEND:
ApplyRemainingOprt(stOpt, stVal);
break;
case cmBC:
{
// The argument count for parameterless functions is zero
// by default an opening bracket sets parameter count to 1
// in preparation of arguments to come. If the last token
// was an opening bracket we know better...
if (opta.GetCode()==cmBO)
{
--stArgCount.top();
}
ApplyRemainingOprt(stOpt, stVal);
// Check if the bracket content has been evaluated completely
if (stOpt.size() && stOpt.top().GetCode()==cmBO)
{
// if opt is ")" and opta is "(" the bracket has been evaluated, now its time to check
// if there is either a function or a sign pending
// neither the opening nor the closing bracket will be pushed back to
// the operator stack
// Check if a function is standing in front of the opening bracket,
// if yes evaluate it afterwards check for infix operators
assert(stArgCount.size());
int iArgCount = stArgCount.pop();
stOpt.pop(); // Take opening bracket from stack
if (iArgCount>1 && ( stOpt.size()==0 || (stOpt.top().GetCode()!=cmFUNC &&
stOpt.top().GetCode()!=cmFUNC_BULK &&
stOpt.top().GetCode()!=cmFUNC_STR) ) )
{
Error(ecUNEXPECTED_ARG, m_pTokenReader->GetPos());
}
// The opening bracket was popped from the stack now check if there
// was a function before this bracket
if (stOpt.size() && stOpt.top().GetCode()!=cmOPRT_INFIX && stOpt.top().GetCode()!=cmOPRT_BIN &&
stOpt.top().GetFuncAddr()!=0)
{
ApplyFunc(stOpt, stVal, iArgCount);
}
}
} // if bracket content is evaluated
break;
//
// Next are the binary operator entries
//
//case cmAND: // built in binary operators
//case cmOR:
//case cmXOR:
case cmIF:
m_nIfElseCounter++;
// fallthrough intentional (no break!)
case cmLAND:
case cmLOR:
case cmLT:
case cmGT:
case cmLE:
case cmGE:
case cmNEQ:
case cmEQ:
case cmADD:
case cmSUB:
case cmMUL:
case cmDIV:
case cmPOW:
case cmASSIGN:
case cmOPRT_BIN:
// A binary operator (user defined or built in) has been found.
while ( stOpt.size() && stOpt.top().GetCode() != cmBO && stOpt.top().GetCode() != cmELSE &&
stOpt.top().GetCode() != cmIF)
{
int nPrec1 = GetOprtPrecedence(stOpt.top()),
nPrec2 = GetOprtPrecedence(opt);
if (stOpt.top().GetCode()==opt.GetCode())
{
// Deal with operator associativity
EOprtAssociativity eOprtAsct = GetOprtAssociativity(opt);
if ( (eOprtAsct==oaRIGHT && (nPrec1 <= nPrec2)) ||
(eOprtAsct==oaLEFT && (nPrec1 < nPrec2)) )
{
break;
}
}
else if (nPrec1 < nPrec2)
{
// In case the operators are not equal the precedence decides alone...
break;
}
if (stOpt.top().GetCode()==cmOPRT_INFIX)
{
ApplyFunc(stOpt, stVal, 1);
}
else
{
ApplyBinOprt(stOpt, stVal);
}
} // while ( ... )
if (opt.GetCode()==cmIF)
{
m_vRPN.AddIfElse(opt.GetCode());
}
// The operator can't be evaluated right now, push back to the operator stack
stOpt.push(opt);
break;
//
// Last section contains functions and operators implicitely mapped to functions
//
case cmBO:
stArgCount.push(1);
stOpt.push(opt);
break;
case cmOPRT_INFIX:
case cmFUNC:
case cmFUNC_BULK:
case cmFUNC_STR:
stOpt.push(opt);
break;
case cmOPRT_POSTFIX:
stOpt.push(opt);
ApplyFunc(stOpt, stVal, 1); // this is the postfix operator
break;
case cmENDIF:
case cmVARPOW2:
case cmVARPOW3:
case cmVARPOW4:
case cmVARMUL:
case cmPOW2:
case cmUNKNOWN:
default:
Error(ecINTERNAL_ERROR, 3);
} // end of switch operator-token
opta = opt;
if ( opt.GetCode() == cmEND )
{
m_vRPN.Finalize();
break;
}
if (QmuParserBase::g_DbgDumpStack)
{
StackDump(stVal, stOpt);
m_vRPN.AsciiDump();
}
} // while (true)
if (QmuParserBase::g_DbgDumpCmdCode)
{
m_vRPN.AsciiDump();
}
if (m_nIfElseCounter>0)
{
Error(ecMISSING_ELSE_CLAUSE);
}
// get the last value (= final result) from the stack
Q_ASSERT(stArgCount.size()==1);
m_nFinalResultIdx = stArgCount.top();
if (m_nFinalResultIdx==0)
{
Error(ecINTERNAL_ERROR, 9);
}
if (stVal.size()==0)
{
Error(ecEMPTY_EXPRESSION);
}
if (stVal.top().GetType()!=tpDBL)
{
Error(ecSTR_RESULT);
}
m_vStackBuffer.resize(m_vRPN.GetMaxStackSize() * s_MaxNumOpenMPThreads);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief One of the two main parse functions.
* @sa ParseCmdCode(...)
*
* Parse expression from input string. Perform syntax checking and create bytecode. After parsing the string and
* creating the bytecode the function pointer #m_pParseFormula will be changed to the second parse routine the
* uses bytecode instead of string parsing.
*/
qreal QmuParserBase::ParseString() const
{
try
{
CreateRPN();
m_pParseFormula = &QmuParserBase::ParseCmdCode;
return (this->*m_pParseFormula)();
}
catch (qmu::QmuParserError &exc)
{
exc.SetFormula(m_pTokenReader->GetExpr());
throw;
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Create an error containing the parse error position.
*
* This function will create an Parser Exception object containing the error text and its position.
*
* @param a_iErrc [in] The error code of type #EErrorCodes.
* @param a_iPos [in] The position where the error was detected.
* @param a_strTok [in] The token string representation associated with the error.
* @throw ParserException always throws thats the only purpose of this function.
*/
void Q_NORETURN QmuParserBase::Error(EErrorCodes a_iErrc, int a_iPos, const QString &a_sTok) const
{
throw qmu::QmuParserError (a_iErrc, a_sTok, m_pTokenReader->GetExpr(), a_iPos);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined variables.
* @throw nothrow
*
* Resets the parser to string parsing mode by calling #ReInit.
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::ClearVar() Q_DECL_NOEXCEPT
{
m_VarDef.clear();
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Remove a variable from internal storage.
* @throw nothrow
*
* Removes a variable if it exists. If the Variable does not exist nothing will be done.
*/
void QmuParserBase::RemoveVar(const QString &a_strVarName) Q_DECL_NOEXCEPT
{
varmap_type::iterator item = m_VarDef.find(a_strVarName);
if (item!=m_VarDef.end())
{
m_VarDef.erase(item);
ReInit();
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all functions.
* @post Resets the parser to string parsing mode.
* @throw nothrow
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::ClearFun() Q_DECL_NOEXCEPT
{
m_FunDef.clear();
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined constants.
*
* Both numeric and string constants will be removed from the internal storage.
* @post Resets the parser to string parsing mode.
* @throw nothrow
*/
void QmuParserBase::ClearConst() Q_DECL_NOEXCEPT
{
m_ConstDef.clear();
m_StrVarDef.clear();
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined postfix operators.
* @post Resets the parser to string parsing mode.
* @throw nothrow
*/
void QmuParserBase::ClearPostfixOprt() Q_DECL_NOEXCEPT
{
m_PostOprtDef.clear();
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined binary operators.
* @post Resets the parser to string parsing mode.
* @throw nothrow
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::ClearOprt() Q_DECL_NOEXCEPT
{
m_OprtDef.clear();
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear the user defined Prefix operators.
* @post Resets the parser to string parser mode.
* @throw nothrow
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::ClearInfixOprt() Q_DECL_NOEXCEPT
{
m_InfixOprtDef.clear();
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Enable or disable the formula optimization feature.
* @post Resets the parser to string parser mode.
* @throw nothrow
*/
void QmuParserBase::EnableOptimizer(bool a_bIsOn) Q_DECL_NOEXCEPT
{
m_vRPN.EnableOptimizer(a_bIsOn);
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Enable the dumping of bytecode amd stack content on the console.
* @param bDumpCmd Flag to enable dumping of the current bytecode to the console.
* @param bDumpStack Flag to enable dumping of the stack content is written to the console.
*
* This function is for debug purposes only!
*/
// cppcheck-suppress unusedFunction
void QmuParserBase::EnableDebugDump(bool bDumpCmd, bool bDumpStack)
{
QmuParserBase::g_DbgDumpCmdCode = bDumpCmd;
QmuParserBase::g_DbgDumpStack = bDumpStack;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Enable or disable the built in binary operators.
* @throw nothrow
* @sa m_bBuiltInOp, ReInit()
*
* If you disable the built in binary operators there will be no binary operators defined. Thus you must add them
* manually one by one. It is not possible to disable built in operators selectively. This function will Reinitialize
* the parser by calling ReInit().
*/
void QmuParserBase::EnableBuiltInOprt(bool a_bIsOn) Q_DECL_NOEXCEPT
{
m_bBuiltInOp = a_bIsOn;
ReInit();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get the argument separator character.
*/
QChar QmuParserBase::GetArgSep() const
{
return m_pTokenReader->GetArgSep();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set argument separator.
* @param cArgSep the argument separator character.
*/
void QmuParserBase::SetArgSep(char_type cArgSep)
{
m_pTokenReader->SetArgSep(cArgSep);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Dump stack content.
*
* This function is used for debugging only.
*/
void QmuParserBase::StackDump(const QStack<token_type> &a_stVal, const QStack<token_type> &a_stOprt) const
{
QStack<token_type> stOprt(a_stOprt),
stVal(a_stVal);
qDebug() << "\nValue stack:\n";
while ( stVal.empty() == false )
{
token_type val = stVal.pop();
if (val.GetType()==tpSTR)
{
qDebug() << " \"" << val.GetAsString() << "\" ";
}
else
{
qDebug() << " " << val.GetVal() << " ";
}
}
qDebug() << "\nOperator stack:\n";
while ( stOprt.empty() == false )
{
if (stOprt.top().GetCode()<=cmASSIGN)
{
qDebug() << "OPRT_INTRNL \"" << QmuParserBase::c_DefaultOprt[stOprt.top().GetCode()] << "\" \n";
}
else
{
switch ( stOprt.top().GetCode())
{
case cmVAR:
qDebug() << "VAR\n";
break;
case cmVAL:
qDebug() << "VAL\n";
break;
case cmFUNC:
qDebug() << "FUNC \"" << stOprt.top().GetAsString() << "\"\n";
break;
case cmFUNC_BULK:
qDebug() << "FUNC_BULK \"" << stOprt.top().GetAsString() << "\"\n";
break;
case cmOPRT_INFIX:
qDebug() << "OPRT_INFIX \"" << stOprt.top().GetAsString() << "\"\n";
break;
case cmOPRT_BIN:
qDebug() << "OPRT_BIN \"" << stOprt.top().GetAsString() << "\"\n";
break;
case cmFUNC_STR:
qDebug() << "FUNC_STR\n";
break;
case cmEND:
qDebug() << "END\n";
break;
case cmUNKNOWN:
qDebug() << "UNKNOWN\n";
break;
case cmBO:
qDebug() << "BRACKET \"(\"\n";
break;
case cmBC:
qDebug() << "BRACKET \")\"\n";
break;
case cmIF:
qDebug() << "IF\n";
break;
case cmELSE:
qDebug() << "ELSE\n";
break;
case cmENDIF:
qDebug() << "ENDIF\n";
break;
case cmLE:
case cmGE:
case cmNEQ:
case cmEQ:
case cmLT:
case cmGT:
case cmADD:
case cmSUB:
case cmMUL:
case cmDIV:
case cmPOW:
case cmLAND:
case cmLOR:
case cmASSIGN:
case cmARG_SEP:
case cmVARPOW2:
case cmVARPOW3:
case cmVARPOW4:
case cmVARMUL:
case cmPOW2:
case cmSTRING:
case cmOPRT_POSTFIX:
default:
qDebug() << stOprt.top().GetCode() << " ";
break;
}
}
stOprt.pop();
}
qDebug() << dec;
}
//---------------------------------------------------------------------------------------------------------------------
/** @brief Evaluate an expression containing comma seperated subexpressions
* @param [out] nStackSize The total number of results available
* @return Pointer to the array containing all expression results
*
* This member function can be used to retriev all results of an expression made up of multiple comma seperated
* subexpressions (i.e. "x+y,sin(x),cos(y)")
*/
qreal* QmuParserBase::Eval(int &nStackSize) const
{
(this->*m_pParseFormula)();
nStackSize = m_nFinalResultIdx;
// (for historic reasons the stack starts at position 1)
return &m_vStackBuffer[1];
}
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::Eval(qreal *results, int nBulkSize) const
{
CreateRPN();
int i = 0;
#ifdef QMUP_USE_OPENMP
//#define DEBUG_OMP_STUFF
#ifdef DEBUG_OMP_STUFF
int *pThread = new int[nBulkSize];
int *pIdx = new int[nBulkSize];
#endif
int nMaxThreads = qMin(omp_get_max_threads(), s_MaxNumOpenMPThreads);
// cppcheck-suppress variableScope
int nThreadID;
// cppcheck-suppress unreadVariable
int ct=0;
omp_set_num_threads(nMaxThreads);
#pragma omp parallel for schedule(static, nBulkSize/nMaxThreads) private(nThreadID)
for (i=0; i<nBulkSize; ++i)
{
nThreadID = omp_get_thread_num();
results[i] = ParseCmdCodeBulk(i, nThreadID);
#ifdef DEBUG_OMP_STUFF
#pragma omp critical
{
pThread[ct] = nThreadID;
pIdx[ct] = i;
ct++;
}
#endif
}
#ifdef DEBUG_OMP_STUFF
FILE *pFile = fopen("bulk_dbg.txt", "w");
for (i=0; i<nBulkSize; ++i)
{
fprintf(pFile, "idx: %d thread: %d \n", pIdx[i], pThread[i]);
}
delete [] pIdx;
delete [] pThread;
fclose(pFile);
#endif
#else
for (i=0; i<nBulkSize; ++i)
{
results[i] = ParseCmdCodeBulk(i, 0);
}
#endif
}
} // namespace qmu
Reference in a new issue View git blame Copy permalink