aw/valentina
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

QStack instead QmuParserStack.

Browse Source 
--HG--
branch : feature
This commit is contained in:
dismine 2014-04-26 09:01:41 +03:00
parent 2f97def4bf
commit 59c7405b88
5 changed files with 32 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/libs/qmuparser/qmuparser.pro
View File

@ -45,7 +45,6 @@ HEADERS += \
qmuparser_global.h \ qmuparser_global.h \
qmuparsertokenreader.h \ qmuparsertokenreader.h \
qmuparsertoken.h \ qmuparsertoken.h \
qmuparserstack.h \
qmuparserfixes.h \ qmuparserfixes.h \
qmuparsererror.h \ qmuparsererror.h \
qmuparserdef.h \ qmuparserdef.h \

47
src/libs/qmuparser/qmuparserbase.cpp
View File

@ -397,20 +397,22 @@ namespace qmu
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
/** \brief Set the formula. /** \brief Set the formula.
\param a_strFormula Formula as string_type \param a_strFormula Formula as string_type
\throw ParserException in case of syntax errors. \throw ParserException in case of syntax errors.
Triggers first time calculation thus the creation of the bytecode and Triggers first time calculation thus the creation of the bytecode and
scanning of used variables. scanning of used variables.
*/ */
void QmuParserBase::SetExpr(const string_type &a_sExpr) void QmuParserBase::SetExpr(const string_type &a_sExpr)
{ {
// Check locale compatibility // Check locale compatibility
std::locale loc; std::locale loc;
if (m_pTokenReader->GetArgSep()==std::use_facet<numpunct<char_type> >(loc).decimal_point()) if (m_pTokenReader->GetArgSep()==std::use_facet<numpunct<char_type> >(loc).decimal_point())
Error(ecLOCALE); {
Error(ecLOCALE);
}
// <ibg> 20060222: Bugfix for Borland-Kylix: // <ibg> 20060222: Bugfix for Borland-Kylix:
// adding a space to the expression will keep Borlands KYLIX from going wild // adding a space to the expression will keep Borlands KYLIX from going wild
@ -420,7 +422,7 @@ namespace qmu
string_type sBuf(a_sExpr + " " ); string_type sBuf(a_sExpr + " " );
m_pTokenReader->SetFormula(sBuf); m_pTokenReader->SetFormula(sBuf);
ReInit(); ReInit();
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
/** \brief Get the default symbols used for the built in operators. /** \brief Get the default symbols used for the built in operators.
@ -786,9 +788,7 @@ namespace qmu
\post The function token is removed from the stack \post The function token is removed from the stack
\throw exception_type if Argument count does not mach function requirements. \throw exception_type if Argument count does not mach function requirements.
*/ */
void QmuParserBase::ApplyFunc( QmuParserStack<token_type> &a_stOpt, void QmuParserBase::ApplyFunc( QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal, int a_iArgCount) const
QmuParserStack<token_type> &a_stVal,
int a_iArgCount) const
{ {
assert(m_pTokenReader.get()); assert(m_pTokenReader.get());
@ -866,8 +866,7 @@ namespace qmu
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void QmuParserBase::ApplyIfElse(QmuParserStack<token_type> &a_stOpt, void QmuParserBase::ApplyIfElse(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const
QmuParserStack<token_type> &a_stVal) const
{ {
// Check if there is an if Else clause to be calculated // Check if there is an if Else clause to be calculated
while (a_stOpt.size() && a_stOpt.top().GetCode()==cmELSE) while (a_stOpt.size() && a_stOpt.top().GetCode()==cmELSE)
@ -900,8 +899,7 @@ namespace qmu
/** \brief Performs the necessary steps to write code for /** \brief Performs the necessary steps to write code for
the execution of binary operators into the bytecode. the execution of binary operators into the bytecode.
*/ */
void QmuParserBase::ApplyBinOprt(QmuParserStack<token_type> &a_stOpt, void QmuParserBase::ApplyBinOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const
QmuParserStack<token_type> &a_stVal) const
{ {
// is it a user defined binary operator? // is it a user defined binary operator?
if (a_stOpt.top().GetCode()==cmOPRT_BIN) if (a_stOpt.top().GetCode()==cmOPRT_BIN)
@ -940,8 +938,7 @@ namespace qmu
\param a_stOpt The operator stack \param a_stOpt The operator stack
\param a_stVal The value stack \param a_stVal The value stack
*/ */
void QmuParserBase::ApplyRemainingOprt(QmuParserStack<token_type> &stOpt, void QmuParserBase::ApplyRemainingOprt(QStack<token_type> &stOpt, QStack<token_type> &stVal) const
QmuParserStack<token_type> &stVal) const
{ {
while (stOpt.size() && while (stOpt.size() &&
stOpt.top().GetCode() != cmBO && stOpt.top().GetCode() != cmBO &&
@ -1179,8 +1176,8 @@ namespace qmu
if (!m_pTokenReader->GetExpr().length()) if (!m_pTokenReader->GetExpr().length())
Error(ecUNEXPECTED_EOF, 0); Error(ecUNEXPECTED_EOF, 0);
QmuParserStack<token_type> stOpt, stVal; QStack<token_type> stOpt, stVal;
QmuParserStack<int> stArgCount; QStack<int> stArgCount;
token_type opta, opt; // for storing operators token_type opta, opt; // for storing operators
token_type val, tval; // for storing value token_type val, tval; // for storing value
string_type strBuf; // buffer for string function arguments string_type strBuf; // buffer for string function arguments
@ -1604,10 +1601,10 @@ namespace qmu
This function is used for debugging only. This function is used for debugging only.
*/ */
void QmuParserBase::StackDump(const QmuParserStack<token_type> &a_stVal, void QmuParserBase::StackDump(const QStack<token_type> &a_stVal,
const QmuParserStack<token_type> &a_stOprt) const const QStack<token_type> &a_stOprt) const
{ {
QmuParserStack<token_type> stOprt(a_stOprt), QStack<token_type> stOprt(a_stOprt),
stVal(a_stVal); stVal(a_stVal);
mu::console() << "\nValue stack:\n"; mu::console() << "\nValue stack:\n";

22
src/libs/qmuparser/qmuparserbase.h
View File

@ -30,6 +30,7 @@
#include <map> #include <map>
#include <memory> #include <memory>
#include <locale> #include <locale>
#include <QStack>
//--- Parser includes -------------------------------------------------------------------------- //--- Parser includes --------------------------------------------------------------------------
#include "qmuparserdef.h" #include "qmuparserdef.h"
@ -101,7 +102,7 @@ private:
virtual ~QmuParserBase(); virtual ~QmuParserBase();
qreal Eval() const; qreal Eval() const;
qreal* Eval(int &nStackSize) const; qreal* Eval(int &nStackSize) const;
void Eval(qreal *results, int nBulkSize); void Eval(qreal *results, int nBulkSize);
@ -239,17 +240,10 @@ private:
funmap_type &a_Storage, funmap_type &a_Storage,
const char_type *a_szCharSet ); const char_type *a_szCharSet );
void ApplyRemainingOprt(QmuParserStack<token_type> &a_stOpt, void ApplyRemainingOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
QmuParserStack<token_type> &a_stVal) const; void ApplyBinOprt(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
void ApplyBinOprt(QmuParserStack<token_type> &a_stOpt, void ApplyIfElse(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal) const;
QmuParserStack<token_type> &a_stVal) const; void ApplyFunc(QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal, int iArgCount) const;
void ApplyIfElse(QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal) const;
void ApplyFunc(QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal,
int iArgCount) const;
token_type ApplyStrFunc(const token_type &a_FunTok, token_type ApplyStrFunc(const token_type &a_FunTok,
const std::vector<token_type> &a_vArg) const; const std::vector<token_type> &a_vArg) const;
@ -268,8 +262,8 @@ private:
const QmuParserCallback &a_Callback, const QmuParserCallback &a_Callback,
const string_type &a_szCharSet) const; const string_type &a_szCharSet) const;
void StackDump(const QmuParserStack<token_type > &a_stVal, void StackDump(const QStack<token_type > &a_stVal,
const QmuParserStack<token_type > &a_stOprt) const; const QStack<token_type > &a_stOprt) const;
/** \brief Pointer to the parser function. /** \brief Pointer to the parser function.

2
src/libs/qmuparser/qmuparserbytecode.cpp
View File

@ -424,7 +424,7 @@ namespace qmu
rpn_type(m_vRPN).swap(m_vRPN); // shrink bytecode vector to fit rpn_type(m_vRPN).swap(m_vRPN); // shrink bytecode vector to fit
// Determine the if-then-else jump offsets // Determine the if-then-else jump offsets
QmuParserStack<int> stIf, stElse; QStack<int> stIf, stElse;
int idx; int idx;
for (int i=0; i<(int)m_vRPN.size(); ++i) for (int i=0; i<(int)m_vRPN.size(); ++i)
{ {

122
src/libs/qmuparser/qmuparserstack.h
View File

@ -1,122 +0,0 @@
/***************************************************************************************************
**
** Original work Copyright (C) 2013 Ingo Berg
** Modified work Copyright 2014 Roman Telezhinsky <dismine@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.
**
******************************************************************************************************/
#ifndef QMUPARSERSTACK_H
#define QMUPARSERSTACK_H
#include <cassert>
#include <string>
#include <stack>
#include <vector>
#include "qmuparsererror.h"
#include "qmuparsertoken.h"
/** \file
\brief This file defines the stack used by muparser.
*/
namespace qmu
{
/** \brief Parser stack implementation.
Stack implementation based on a std::stack. The behaviour of pop() had been
slightly changed in order to get an error code if the stack is empty.
The stack is used within the Parser both as a value stack and as an operator stack.
\author (C) 2004-2011 Ingo Berg
*/
template <typename TValueType>
class QmuParserStack
{
private:
/** \brief Type of the underlying stack implementation. */
typedef std::stack<TValueType, std::vector<TValueType> > impl_type;
impl_type m_Stack; ///< This is the actual stack.
public:
//---------------------------------------------------------------------------
QmuParserStack()
:m_Stack()
{}
//---------------------------------------------------------------------------
virtual ~QmuParserStack()
{}
//---------------------------------------------------------------------------
/** \brief Pop a value from the stack.
Unlike the standard implementation this function will return the value that
is going to be taken from the stack.
\throw ParserException in case the stack is empty.
\sa pop(int &a_iErrc)
*/
TValueType pop()
{
if (empty())
throw QmuParserError( "stack is empty." );
TValueType el = top();
m_Stack.pop();
return el;
}
/** \brief Push an object into the stack.
\param a_Val object to push into the stack.
\throw nothrow
*/
void push(const TValueType& a_Val)
{
m_Stack.push(a_Val);
}
/** \brief Return the number of stored elements. */
unsigned size() const
{
return (unsigned)m_Stack.size();
}
/** \brief Returns true if stack is empty false otherwise. */
bool empty() const
{
return m_Stack.size()==0;
}
/** \brief Return reference to the top object in the stack.
The top object is the one pushed most recently.
*/
TValueType& top()
{
return m_Stack.top();
}
};
} // namespace MathUtils
#endif