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 \
qmuparsertokenreader.h \
qmuparsertoken.h \
qmuparserstack.h \
qmuparserfixes.h \
qmuparsererror.h \
qmuparserdef.h \

37
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
\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 string_type &a_sExpr)
{
*/
void QmuParserBase::SetExpr(const string_type &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
@ -420,7 +422,7 @@ namespace qmu
string_type sBuf(a_sExpr + " " );
m_pTokenReader->SetFormula(sBuf);
ReInit();
}
}
//---------------------------------------------------------------------------
/** \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
\throw exception_type if Argument count does not mach function requirements.
*/
void QmuParserBase::ApplyFunc( QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal,
int a_iArgCount) const
void QmuParserBase::ApplyFunc( QStack<token_type> &a_stOpt, QStack<token_type> &a_stVal, int a_iArgCount) const
{
assert(m_pTokenReader.get());
@ -866,8 +866,7 @@ namespace qmu
}
//---------------------------------------------------------------------------
void QmuParserBase::ApplyIfElse(QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal) const
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)
@ -900,8 +899,7 @@ namespace qmu
/** \brief Performs the necessary steps to write code for
the execution of binary operators into the bytecode.
*/
void QmuParserBase::ApplyBinOprt(QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal) const
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)
@ -940,8 +938,7 @@ namespace qmu
\param a_stOpt The operator stack
\param a_stVal The value stack
*/
void QmuParserBase::ApplyRemainingOprt(QmuParserStack<token_type> &stOpt,
QmuParserStack<token_type> &stVal) const
void QmuParserBase::ApplyRemainingOprt(QStack<token_type> &stOpt, QStack<token_type> &stVal) const
{
while (stOpt.size() &&
stOpt.top().GetCode() != cmBO &&
@ -1179,8 +1176,8 @@ namespace qmu
if (!m_pTokenReader->GetExpr().length())
Error(ecUNEXPECTED_EOF, 0);
QmuParserStack<token_type> stOpt, stVal;
QmuParserStack<int> stArgCount;
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
@ -1604,10 +1601,10 @@ namespace qmu
This function is used for debugging only.
*/
void QmuParserBase::StackDump(const QmuParserStack<token_type> &a_stVal,
const QmuParserStack<token_type> &a_stOprt) const
void QmuParserBase::StackDump(const QStack<token_type> &a_stVal,
const QStack<token_type> &a_stOprt) const
{
QmuParserStack<token_type> stOprt(a_stOprt),
QStack<token_type> stOprt(a_stOprt),
stVal(a_stVal);
mu::console() << "\nValue stack:\n";

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

@ -30,6 +30,7 @@
#include <map>
#include <memory>
#include <locale>
#include <QStack>
//--- Parser includes --------------------------------------------------------------------------
#include "qmuparserdef.h"
@ -239,17 +240,10 @@ private:
funmap_type &a_Storage,
const char_type *a_szCharSet );
void ApplyRemainingOprt(QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal) const;
void ApplyBinOprt(QmuParserStack<token_type> &a_stOpt,
QmuParserStack<token_type> &a_stVal) 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;
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 std::vector<token_type> &a_vArg) const;
@ -268,8 +262,8 @@ private:
const QmuParserCallback &a_Callback,
const string_type &a_szCharSet) const;
void StackDump(const QmuParserStack<token_type > &a_stVal,
const QmuParserStack<token_type > &a_stOprt) const;
void StackDump(const QStack<token_type > &a_stVal,
const QStack<token_type > &a_stOprt) const;
/** \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
// Determine the if-then-else jump offsets
QmuParserStack<int> stIf, stElse;
QStack<int> stIf, stElse;
int idx;
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