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

Vera++.

Browse Source 
--HG--
branch : feature
This commit is contained in:
dismine 2014-05-01 14:33:40 +03:00
parent 37ecf9fd86
commit 362638066a
41 changed files with 7158 additions and 7036 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/app/container/vmeasurement.cpp
View File

@ -61,7 +61,3 @@ qreal VMeasurement::GetValue(const qreal &size, const qreal &height) const
const qreal k_height = ( height - 176.0 ) / 6.0;
return base + k_size * ksize + k_height * kheight;
}

4
src/app/dialogs/tools/dialogdetail.cpp
View File

@ -105,8 +105,8 @@ void DialogDetail::DialogAccepted()
emit DialogClosed(QDialog::Accepted);
}
void DialogDetail::NewItem(quint32 id, const Valentina::Tools &typeTool, const NodeDetail::NodeDetails &typeNode, qreal mx,
qreal my)
void DialogDetail::NewItem(quint32 id, const Valentina::Tools &typeTool, const NodeDetail::NodeDetails &typeNode,
qreal mx, qreal my)
{
QString name;
switch (typeTool)

3
src/app/dialogs/tools/dialoguniondetails.h
View File

@ -133,7 +133,8 @@ private:
* @param idDetail id detail
* @param index index of edge
*/
void ChoosedDetail(const quint32 &id, const Valentina::Scenes &type, quint32 &idDetail, ptrdiff_t &index);
void ChoosedDetail(const quint32 &id, const Valentina::Scenes &type, quint32 &idDetail,
ptrdiff_t &index);
};
inline quint32 DialogUnionDetails::getD1() const

3
src/app/main.cpp
View File

@ -70,7 +70,8 @@ void noisyFailureMsgHandler(QtMsgType type, const QMessageLogContext &context, c
{
QByteArray localMsg = msg.toLocal8Bit();
QMessageBox messageBox;
switch (type) {
switch (type)
{
case QtDebugMsg:
fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
context.function);

22
src/app/mainwindow.cpp
View File

@ -157,8 +157,8 @@ void MainWindow::ActionNewDraw()
pattern->ClearGObjects();
//Create single point
const quint32 id = pattern->AddGObject(new VPointF(qApp->toPixel((10+comboBoxDraws->count()*5)), qApp->toPixel(10), "А", 5,
10));
const quint32 id = pattern->AddGObject(new VPointF(qApp->toPixel((10+comboBoxDraws->count()*5)), qApp->toPixel(10),
"А", 5, 10));
VToolSinglePoint *spoint = new VToolSinglePoint(doc, pattern, id, Valentina::FromGui);
sceneDraw->addItem(spoint);
connect(spoint, &VToolPoint::ChoosedTool, sceneDraw, &VMainGraphicsScene::ChoosedItem);
@ -261,8 +261,8 @@ void MainWindow::ClosedDialogLine(int result)
void MainWindow::ToolAlongLine(bool checked)
{
SetToolButton<DialogAlongLine>(checked, Valentina::AlongLineTool, ":/cursor/alongline_cursor.png", tr("Select point"),
&MainWindow::ClosedDialogAlongLine);
SetToolButton<DialogAlongLine>(checked, Valentina::AlongLineTool, ":/cursor/alongline_cursor.png",
tr("Select point"), &MainWindow::ClosedDialogAlongLine);
}
void MainWindow::ClosedDialogAlongLine(int result)
@ -360,8 +360,9 @@ void MainWindow::ClosedDialogSplinePath(int result)
void MainWindow::ToolCutSplinePath(bool checked)
{
SetToolButton<DialogCutSplinePath>(checked, Valentina::CutSplinePathTool, ":/cursor/splinepath_cut_point_cursor.png",
tr("Select curve path"), &MainWindow::ClosedDialogCutSplinePath);
SetToolButton<DialogCutSplinePath>(checked, Valentina::CutSplinePathTool,
":/cursor/splinepath_cut_point_cursor.png", tr("Select curve path"),
&MainWindow::ClosedDialogCutSplinePath);
}
void MainWindow::ClosedDialogCutSplinePath(int result)
@ -420,8 +421,9 @@ void MainWindow::ClosedDialogTriangle(int result)
void MainWindow::ToolPointOfIntersection(bool checked)
{
SetToolButton<DialogPointOfIntersection>(checked, Valentina::PointOfIntersection, ":/cursor/pointofintersect_cursor.png",
tr("Select point vertically"), &MainWindow::ClosedDialogPointOfIntersection);
SetToolButton<DialogPointOfIntersection>(checked, Valentina::PointOfIntersection,
":/cursor/pointofintersect_cursor.png", tr("Select point vertically"),
&MainWindow::ClosedDialogPointOfIntersection);
}
void MainWindow::ClosedDialogPointOfIntersection(int result)
@ -431,8 +433,8 @@ void MainWindow::ClosedDialogPointOfIntersection(int result)
void MainWindow::ToolUnionDetails(bool checked)
{
SetToolButton<DialogUnionDetails>(checked, Valentina::UnionDetails, ":/cursor/union_cursor.png", tr("Select detail"),
&MainWindow::ClosedDialogUnionDetails);
SetToolButton<DialogUnionDetails>(checked, Valentina::UnionDetails, ":/cursor/union_cursor.png",
tr("Select detail"), &MainWindow::ClosedDialogUnionDetails);
//Must disconnect this signal here.
disconnect(doc, &VPattern::FullUpdateFromFile, dialogTool, &DialogTool::UpdateList);
}

6
src/app/tools/drawTools/vtooltriangle.cpp
View File

@ -31,9 +31,9 @@
const QString VToolTriangle::ToolType = QStringLiteral("triangle");
VToolTriangle::VToolTriangle(VPattern *doc, VContainer *data, const quint32 &id,
const quint32 &axisP1Id, const quint32 &axisP2Id, const quint32 &firstPointId,
const quint32 &secondPointId, const Valentina::Sources &typeCreation, QGraphicsItem *parent)
VToolTriangle::VToolTriangle(VPattern *doc, VContainer *data, const quint32 &id, const quint32 &axisP1Id,
const quint32 &axisP2Id, const quint32 &firstPointId, const quint32 &secondPointId,
const Valentina::Sources &typeCreation, QGraphicsItem *parent)
:VToolPoint(doc, data, id, parent), axisP1Id(axisP1Id), axisP2Id(axisP2Id), firstPointId(firstPointId),
secondPointId(secondPointId)
{

5
src/app/tools/nodeDetails/vnodearc.h
View File

@ -48,8 +48,9 @@ public:
* @param typeCreation way we create this tool.
* @param parent parent object.
*/
VNodeArc(VPattern *doc, VContainer *data, quint32 id, quint32 idArc, const Valentina::Sources &typeCreation,
const quint32 &idTool = 0, QObject *qoParent = nullptr, QGraphicsItem * parent = nullptr);
VNodeArc(VPattern *doc, VContainer *data, quint32 id, quint32 idArc,
const Valentina::Sources &typeCreation, const quint32 &idTool = 0,
QObject *qoParent = nullptr, QGraphicsItem * parent = nullptr);
/**
* @brief Create help create tool.
* @param doc dom document container.

10
src/app/tools/nodeDetails/vnodepoint.h
View File

@ -48,9 +48,8 @@ public:
* @param typeCreation way we create this tool.
* @param parent parent object.
*/
VNodePoint(VPattern *doc, VContainer *data, quint32 id, quint32 idPoint,
const Valentina::Sources &typeCreation, const quint32 &idTool = 0, QObject *qoParent = nullptr,
QGraphicsItem * parent = nullptr );
VNodePoint(VPattern *doc, VContainer *data, quint32 id, quint32 idPoint, const Valentina::Sources &typeCreation,
const quint32 &idTool = 0, QObject *qoParent = nullptr, QGraphicsItem * parent = nullptr );
/**
* @brief Create help create tool.
* @param doc dom document container.
@ -60,9 +59,8 @@ public:
* @param parse parser file mode.
* @param typeCreation way we create this tool.
*/
static void Create(VPattern *doc, VContainer *data, quint32 id, quint32 idPoint,
const Document::Documents &parse, const Valentina::Sources &typeCreation, const quint32 &idTool = 0,
QObject *parent = nullptr);
static void Create(VPattern *doc, VContainer *data, quint32 id, quint32 idPoint, const Document::Documents &parse,
const Valentina::Sources &typeCreation, const quint32 &idTool = 0, QObject *parent = nullptr);
static const QString TagName;
static const QString ToolType;
/**

5
src/app/tools/nodeDetails/vnodespline.h
View File

@ -48,9 +48,8 @@ public:
* @param typeCreation way we create this tool.
* @param parent parent object.
*/
VNodeSpline(VPattern *doc, VContainer *data, quint32 id, quint32 idSpline,
const Valentina::Sources &typeCreation, const quint32 &idTool = 0, QObject *qoParent = nullptr,
QGraphicsItem * parent = nullptr);
VNodeSpline(VPattern *doc, VContainer *data, quint32 id, quint32 idSpline, const Valentina::Sources &typeCreation,
const quint32 &idTool = 0, QObject *qoParent = nullptr, QGraphicsItem * parent = nullptr);
/**
* @brief Create help create tool.
* @param doc dom document container.

4
src/app/tools/nodeDetails/vnodesplinepath.cpp
View File

@ -53,8 +53,8 @@ VNodeSplinePath::VNodeSplinePath(VPattern *doc, VContainer *data, quint32 id, qu
}
void VNodeSplinePath::Create(VPattern *doc, VContainer *data, quint32 id, quint32 idSpline,
const Document::Documents &parse, const Valentina::Sources &typeCreation, const quint32 &idTool,
QObject *parent)
const Document::Documents &parse, const Valentina::Sources &typeCreation,
const quint32 &idTool, QObject *parent)
{
VAbstractTool::AddRecord(id, Valentina::NodeSplinePath, doc);
if (parse == Document::FullParse)

5
src/app/tools/nodeDetails/vnodesplinepath.h
View File

@ -60,9 +60,8 @@ public:
* @param parse parser file mode.
* @param typeCreation way we create this tool.
*/
static void Create(VPattern *doc, VContainer *data, quint32 id, quint32 idSpline,
const Document::Documents &parse, const Valentina::Sources &typeCreation, const quint32 &idTool = 0,
QObject *parent = 0);
static void Create(VPattern *doc, VContainer *data, quint32 id, quint32 idSpline, const Document::Documents &parse,
const Valentina::Sources &typeCreation, const quint32 &idTool = 0, QObject *parent = 0);
static const QString TagName;
static const QString ToolType;
/**

3
src/app/xml/vdomdocument.cpp
View File

@ -293,7 +293,8 @@ void VDomDocument::ValidateXML(const QString &schema, const QString &fileName)
pattern.close();
fileSchema.close();
VException e(messageHandler.statusMessage());
e.AddMoreInformation(tr("Validation error in line %1 column %2").arg(messageHandler.line()).arg(messageHandler.column()));
e.AddMoreInformation(tr("Validation error in line %1 column %2").arg(messageHandler.line())
.arg(messageHandler.column()));
throw e;
}
pattern.close();

3
src/app/xml/vpattern.cpp
View File

@ -1049,7 +1049,8 @@ void VPattern::ParsePointElement(VMainGraphicsScene *scene, const QDomElement &d
const QString formula = GetParametrString(domElement, VAbstractTool::AttrLength, "0");
const quint32 splineId = GetParametrUInt(domElement, VToolCutSpline::AttrSpline, "0");
VToolCutSpline::Create(id, name, formula, splineId, mx, my, scene, this, data, parse, Valentina::FromFile);
VToolCutSpline::Create(id, name, formula, splineId, mx, my, scene, this, data, parse,
Valentina::FromFile);
}
catch (const VExceptionBadId &e)
{

48
src/libs/qmuparser/qmuparser.cpp
View File

@ -66,7 +66,7 @@ qreal QmuParser::ATanh(qreal v)
{
return (0.5 * log((1 + v) / (1 - v)));
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
// Logarithm functions
// Logarithm base 2
@ -93,7 +93,7 @@ qreal QmuParser::Log10(qreal v)
return log10(v);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
// misc
qreal QmuParser::Abs(qreal v)
{
@ -110,7 +110,7 @@ qreal QmuParser::Sign(qreal v)
return ((v<0) ? -1 : (v>0) ? 1 : 0);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for the unary minus operator.
* @param v The value to negate
@ -121,7 +121,7 @@ qreal QmuParser::UnaryMinus(qreal v)
return -v;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for adding multiple values.
* @param [in] a_afArg Vector with the function arguments
@ -129,16 +129,19 @@ qreal QmuParser::UnaryMinus(qreal v)
*/
qreal QmuParser::Sum(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
if (a_iArgc == false)
{
throw exception_type("too few arguments for function sum.");
}
qreal fRes=0;
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
for (int i=0; i<a_iArgc; ++i)
{
fRes += a_afArg[i];
}
return fRes;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for averaging multiple values.
* @param [in] a_afArg Vector with the function arguments
@ -146,16 +149,19 @@ qreal QmuParser::Sum(const qreal *a_afArg, int a_iArgc)
*/
qreal QmuParser::Avg(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
if (a_iArgc == false)
{
throw exception_type("too few arguments for function sum.");
}
qreal fRes=0;
for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
for (int i=0; i<a_iArgc; ++i)
{
fRes += a_afArg[i];
}
return fRes/static_cast<qreal>(a_iArgc);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for determining the minimum value out of a vector.
* @param [in] a_afArg Vector with the function arguments
@ -163,7 +169,7 @@ qreal QmuParser::Avg(const qreal *a_afArg, int a_iArgc)
*/
qreal QmuParser::Min(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
if (a_iArgc == false)
{
throw exception_type("too few arguments for function min.");
}
@ -175,7 +181,7 @@ qreal QmuParser::Min(const qreal *a_afArg, int a_iArgc)
return fRes;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Callback for determining the maximum value out of a vector.
* @param [in] a_afArg Vector with the function arguments
@ -183,7 +189,7 @@ qreal QmuParser::Min(const qreal *a_afArg, int a_iArgc)
*/
qreal QmuParser::Max(const qreal *a_afArg, int a_iArgc)
{
if (!a_iArgc)
if (a_iArgc == false)
{
throw exception_type("too few arguments for function min.");
}
@ -195,7 +201,7 @@ qreal QmuParser::Max(const qreal *a_afArg, int a_iArgc)
return fRes;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Default value recognition callback.
* @param [in] a_szExpr Pointer to the expression
@ -228,7 +234,7 @@ int QmuParser::IsVal(const QString &a_szExpr, int *a_iPos, qreal *a_fVal)
return 1;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor.
*
@ -244,7 +250,7 @@ QmuParser::QmuParser():QmuParserBase()
InitOprt();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define the character sets.
* @sa DefineNameChars, DefineOprtChars, DefineInfixOprtChars
@ -259,7 +265,7 @@ void QmuParser::InitCharSets()
DefineInfixOprtChars( "/+-*^?<>=#!$%&|~'_" );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize the default functions.
*/
@ -300,7 +306,7 @@ void QmuParser::InitFun()
DefineFun("max", Max);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize constants.
*
@ -313,7 +319,7 @@ void QmuParser::InitConst()
DefineConst("_e", (qreal)M_E);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize operators.
*
@ -324,7 +330,7 @@ void QmuParser::InitOprt()
DefineInfixOprt("-", UnaryMinus);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParser::OnDetectVar(const QString &pExpr, int &nStart, int &nEnd)
{
Q_UNUSED(pExpr);
@ -352,7 +358,7 @@ void QmuParser::OnDetectVar(const QString &pExpr, int &nStart, int &nEnd)
*/
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Numerically differentiate with regard to a variable.
* @param [in] a_Var Pointer to the differentiation variable.

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

@ -51,7 +51,7 @@ const QStringList QmuParserBase::c_DefaultOprt = QStringList() << "<=" << ">=" <
<< "+" << "-" << "*" << "/" << "^" << "&&"
<< "||" << "=" << "(" << ")" << "?" << ":";
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor.
* @param a_szFormula the formula to interpret.
@ -66,7 +66,7 @@ QmuParserBase::QmuParserBase()
InitTokenReader();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy constructor.
*
@ -82,11 +82,11 @@ QmuParserBase::QmuParserBase(const QmuParserBase &a_Parser)
Assign(a_Parser);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QmuParserBase::~QmuParserBase()
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Assignement operator.
*
@ -101,7 +101,7 @@ QmuParserBase& QmuParserBase::operator=(const QmuParserBase &a_Parser)
return *this;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy state of a parser object to this.
*
@ -144,7 +144,7 @@ void QmuParserBase::Assign(const QmuParserBase &a_Parser)
m_sInfixOprtChars = a_Parser.m_sInfixOprtChars;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set the decimal separator.
* @param cDecSep Decimal separator as a character value.
@ -159,7 +159,7 @@ void QmuParserBase::SetDecSep(char_type cDecSep)
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
@ -174,7 +174,7 @@ void QmuParserBase::SetThousandsSep(char_type cThousandsSep)
s_locale = std::locale(std::locale("C"), new change_dec_sep<char_type>(cDecSep, cThousandsSep));
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Resets the locale.
*
@ -186,7 +186,7 @@ void QmuParserBase::ResetLocale()
SetArgSep(',');
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize the token reader.
*
@ -200,7 +200,7 @@ void QmuParserBase::InitTokenReader()
m_pTokenReader.reset(new token_reader_type(this));
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Reset parser to string parsing mode and clear internal buffers.
*
@ -216,7 +216,7 @@ void QmuParserBase::ReInit() const
m_nIfElseCounter = 0;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::OnDetectVar(const QString &pExpr, int &nStart, int &nEnd)
{
Q_UNUSED(pExpr);
@ -224,7 +224,7 @@ void QmuParserBase::OnDetectVar(const QString &pExpr, int &nStart, int &nEnd)
Q_UNUSED(nEnd);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Returns the version of muparser.
* @param eInfo A flag indicating whether the full version info should be returned or not.
@ -276,7 +276,7 @@ QString QmuParserBase::GetVersion(EParserVersionInfo eInfo) const
return versionInfo;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a value parsing function.
*
@ -288,7 +288,7 @@ void QmuParserBase::AddValIdent(identfun_type a_pCallback)
m_pTokenReader->AddValIdent(a_pCallback);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set a function that can create variable pointer for unknown expression variables.
* @param a_pFactory A pointer to the variable factory.
@ -299,7 +299,7 @@ void QmuParserBase::SetVarFactory(facfun_type a_pFactory, void *pUserData)
m_pTokenReader->SetVarCreator(a_pFactory, pUserData);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a function or operator callback to the parser.
*/
@ -339,7 +339,7 @@ void QmuParserBase::AddCallback(const QString &a_strName, const QmuParserCallbac
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a name contains invalid characters.
*
@ -355,7 +355,7 @@ void QmuParserBase::CheckOprt(const QString &a_sName, const QmuParserCallback &a
const std::string a_sNameStd = a_sName.toStdString();
const std::string a_szCharSetStd = a_szCharSet.toStdString();
#endif
if ( !a_sNameStd.length() || (a_sNameStd.find_first_not_of(a_szCharSetStd)!=string_type::npos) ||
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())
@ -475,7 +475,7 @@ void QmuParserBase::CheckOprt(const QString &a_sName, const QmuParserCallback &a
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a name contains invalid characters.
*
@ -490,14 +490,14 @@ void QmuParserBase::CheckName(const QString &a_sName, const QString &a_szCharSet
std::string a_sNameStd = a_sName.toStdString();
std::string a_szCharSetStd = a_szCharSet.toStdString();
#endif
if ( !a_sNameStd.length() || (a_sNameStd.find_first_not_of(a_szCharSetStd)!=string_type::npos) ||
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
@ -524,7 +524,7 @@ void QmuParserBase::SetExpr(const QString &a_sExpr)
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get the default symbols used for the built in operators.
* @sa c_DefaultOprt
@ -534,7 +534,7 @@ const QStringList &QmuParserBase::GetOprtDef() const
return c_DefaultOprt;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define the set of valid characters to be used in names of functions, variables, constants.
*/
@ -543,7 +543,7 @@ void QmuParserBase::DefineNameChars(const QString &a_szCharset)
m_sNameChars = a_szCharset;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define the set of valid characters to be used in names of binary operators and postfix operators.
*/
@ -552,7 +552,7 @@ void QmuParserBase::DefineOprtChars(const QString &a_szCharset)
m_sOprtChars = a_szCharset;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define the set of valid characters to be used in names of infix operators.
*/
@ -561,7 +561,7 @@ void QmuParserBase::DefineInfixOprtChars(const QString &a_szCharset)
m_sInfixOprtChars = a_szCharset;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Virtual function that defines the characters allowed in name identifiers.
* @sa #ValidOprtChars, #ValidPrefixOprtChars
@ -572,7 +572,7 @@ const QString& QmuParserBase::ValidNameChars() const
return m_sNameChars;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Virtual function that defines the characters allowed in operator definitions.
* @sa #ValidNameChars, #ValidPrefixOprtChars
@ -583,7 +583,7 @@ const QString &QmuParserBase::ValidOprtChars() const
return m_sOprtChars;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Virtual function that defines the characters allowed in infix operator definitions.
* @sa #ValidNameChars, #ValidOprtChars
@ -594,7 +594,7 @@ const QString &QmuParserBase::ValidInfixOprtChars() const
return m_sInfixOprtChars;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined operator.
* @post Will reset the Parser to string parsing mode.
@ -605,7 +605,7 @@ void QmuParserBase::DefinePostfixOprt(const QString &a_sName, fun_type1 a_pFun,
ValidOprtChars() );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize user defined functions.
*
@ -619,7 +619,7 @@ void QmuParserBase::Init()
InitOprt();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined operator.
* @post Will reset the Parser to string parsing mode.
@ -635,7 +635,7 @@ void QmuParserBase::DefineInfixOprt(const QString &a_sName, fun_type1 a_pFun, in
ValidInfixOprtChars() );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define a binary operator.
* @param [in] a_sName The identifier of the operator.
@ -662,7 +662,7 @@ void QmuParserBase::DefineOprt( const QString &a_sName, fun_type2 a_pFun, unsign
ValidOprtChars() );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Define a new string constant.
* @param [in] a_strName The name of the constant.
@ -684,7 +684,7 @@ void QmuParserBase::DefineStrConst(const QString &a_strName, const QString &a_st
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined variable.
* @param [in] a_sName the variable name
@ -710,7 +710,7 @@ void QmuParserBase::DefineVar(const QString &a_sName, qreal *a_pVar)
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a user defined constant.
* @param [in] a_sName The name of the constant.
@ -725,7 +725,7 @@ void QmuParserBase::DefineConst(const QString &a_sName, qreal a_fVal)
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get operator priority.
* @throw ParserException if a_Oprt is no operator code
@ -821,7 +821,7 @@ int QmuParserBase::GetOprtPrecedence(const token_type &a_Tok) const
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get operator priority.
* @throw ParserException if a_Oprt is no operator code
@ -916,7 +916,7 @@ EOprtAssociativity QmuParserBase::GetOprtAssociativity(const token_type &a_Tok)
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return a map containing the used variables only.
*/
@ -941,7 +941,7 @@ const varmap_type& QmuParserBase::GetUsedVar() const
return m_pTokenReader->GetUsedVar();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return a map containing the used variables only.
*/
@ -950,7 +950,7 @@ const varmap_type& QmuParserBase::GetVar() const
return m_VarDef;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return a map containing all parser constants.
*/
@ -959,7 +959,7 @@ const valmap_type& QmuParserBase::GetConst() const
return m_ConstDef;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return prototypes of all parser functions.
* @return #m_FunDef
@ -975,7 +975,7 @@ const funmap_type& QmuParserBase::GetFunDef() const
return m_FunDef;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Retrieve the formula.
*/
@ -984,7 +984,7 @@ const QString& QmuParserBase::GetExpr() const
return m_pTokenReader->GetExpr();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Execute a function that takes a single string argument.
* @param a_FunTok Function token.
@ -1039,7 +1039,7 @@ QmuParserBase::token_type QmuParserBase::ApplyStrFunc(const token_type &a_FunTok
return valTok;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Apply a function token.
* @param iArgCount Number of Arguments actually gathered used only for multiarg functions.
@ -1229,7 +1229,7 @@ void QmuParserBase::ApplyFunc( QStack<token_type> &a_stOpt, QStack<token_type> &
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
@ -1259,7 +1259,7 @@ void QmuParserBase::ApplyIfElse(QStack<token_type> &a_stOpt, QStack<token_type>
} // while pending if-else-clause found
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Performs the necessary steps to write code for the execution of binary operators into the bytecode.
*/
@ -1300,7 +1300,7 @@ void QmuParserBase::ApplyBinOprt(QStack<token_type> &a_stOpt, QStack<token_type>
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Apply a binary operator.
* @param a_stOpt The operator stack
@ -1405,7 +1405,7 @@ void QmuParserBase::ApplyRemainingOprt(QStack<token_type> &stOpt, QStack<token_t
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Parse the command code.
* @sa ParseString(...)
@ -1418,7 +1418,7 @@ qreal QmuParserBase::ParseCmdCode() const
return ParseCmdCodeBulk(0, 0);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Evaluate the RPN.
* @param nOffset The offset added to variable addresses (for bulk mode)
@ -1769,10 +1769,10 @@ qreal QmuParserBase::ParseCmdCodeBulk(int nOffset, int nThreadID) const
return Stack[m_nFinalResultIdx];
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::CreateRPN() const
{
if (!m_pTokenReader->GetExpr().length())
if (m_pTokenReader->GetExpr().length() == false)
{
Error(ecUNEXPECTED_EOF, 0);
}
@ -2027,7 +2027,7 @@ void QmuParserBase::CreateRPN() const
m_vStackBuffer.resize(m_vRPN.GetMaxStackSize() * s_MaxNumOpenMPThreads);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief One of the two main parse functions.
* @sa ParseCmdCode(...)
@ -2051,7 +2051,7 @@ qreal QmuParserBase::ParseString() const
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Create an error containing the parse error position.
*
@ -2067,7 +2067,7 @@ void Q_NORETURN QmuParserBase::Error(EErrorCodes a_iErrc, int a_iPos, const QStr
throw exception_type(a_iErrc, a_sTok, m_pTokenReader->GetExpr(), a_iPos);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined variables.
* @throw nothrow
@ -2080,7 +2080,7 @@ void QmuParserBase::ClearVar()
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Remove a variable from internal storage.
* @throw nothrow
@ -2097,7 +2097,7 @@ void QmuParserBase::RemoveVar(const QString &a_strVarName)
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all functions.
* @post Resets the parser to string parsing mode.
@ -2109,7 +2109,7 @@ void QmuParserBase::ClearFun()
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined constants.
*
@ -2124,7 +2124,7 @@ void QmuParserBase::ClearConst()
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined postfix operators.
* @post Resets the parser to string parsing mode.
@ -2136,7 +2136,7 @@ void QmuParserBase::ClearPostfixOprt()
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear all user defined binary operators.
* @post Resets the parser to string parsing mode.
@ -2148,7 +2148,7 @@ void QmuParserBase::ClearOprt()
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clear the user defined Prefix operators.
* @post Resets the parser to string parser mode.
@ -2160,7 +2160,7 @@ void QmuParserBase::ClearInfixOprt()
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Enable or disable the formula optimization feature.
* @post Resets the parser to string parser mode.
@ -2172,7 +2172,7 @@ void QmuParserBase::EnableOptimizer(bool 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.
@ -2186,7 +2186,7 @@ void QmuParserBase::EnableDebugDump(bool bDumpCmd, bool bDumpStack)
QmuParserBase::g_DbgDumpStack = bDumpStack;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Enable or disable the built in binary operators.
* @throw nothrow
@ -2202,7 +2202,7 @@ void QmuParserBase::EnableBuiltInOprt(bool a_bIsOn)
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Query status of built in variables.
* @return #m_bBuiltInOp; true if built in operators are enabled.
@ -2213,7 +2213,7 @@ bool QmuParserBase::HasBuiltInOprt() const
return m_bBuiltInOp;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get the argument separator character.
*/
@ -2222,7 +2222,7 @@ QChar QmuParserBase::GetArgSep() const
return m_pTokenReader->GetArgSep();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set argument separator.
* @param cArgSep the argument separator character.
@ -2232,7 +2232,7 @@ void QmuParserBase::SetArgSep(char_type cArgSep)
m_pTokenReader->SetArgSep(cArgSep);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Dump stack content.
*
@ -2244,7 +2244,7 @@ void QmuParserBase::StackDump(const QStack<token_type> &a_stVal, const QStack<to
stVal(a_stVal);
qDebug() << "\nValue stack:\n";
while ( !stVal.empty() )
while ( stVal.empty() == false )
{
token_type val = stVal.pop();
if (val.GetType()==tpSTR)
@ -2258,7 +2258,7 @@ void QmuParserBase::StackDump(const QStack<token_type> &a_stVal, const QStack<to
}
qDebug() << "\nOperator stack:\n";
while ( !stOprt.empty() )
while ( stOprt.empty() == false )
{
if (stOprt.top().GetCode()<=cmASSIGN)
{
@ -2386,7 +2386,7 @@ void QmuParserBase::StackDump(const QStack<token_type> &a_stVal, const QStack<to
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
@ -2403,7 +2403,7 @@ qreal* QmuParserBase::Eval(int &nStackSize) const
return &m_vStackBuffer[1];
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the number of results on the calculation stack.
*
@ -2415,7 +2415,7 @@ int QmuParserBase::GetNumResults() const
return m_nFinalResultIdx;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Calculate the result.
*
@ -2437,7 +2437,7 @@ qreal QmuParserBase::Eval() const
return (this->*m_pParseFormula)();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserBase::Eval(qreal *results, int nBulkSize)
{
CreateRPN();
@ -2451,7 +2451,7 @@ void QmuParserBase::Eval(qreal *results, int nBulkSize)
int *pIdx = new int[nBulkSize];
#endif
int nMaxThreads = std::min(omp_get_max_threads(), s_MaxNumOpenMPThreads);
int nMaxThreads = qMin(omp_get_max_threads(), s_MaxNumOpenMPThreads);
int nThreadID, ct=0;
omp_set_num_threads(nMaxThreads);

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

@ -259,4 +259,3 @@ private:
} // namespace qmu
#endif

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

@ -35,7 +35,7 @@
namespace qmu
{
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Bytecode default constructor.
*/
@ -45,7 +45,7 @@ QmuParserByteCode::QmuParserByteCode()
m_vRPN.reserve(50);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy constructor.
*
@ -58,7 +58,7 @@ QmuParserByteCode::QmuParserByteCode(const QmuParserByteCode &a_ByteCode)
Assign(a_ByteCode);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Assignment operator.
*
@ -70,13 +70,13 @@ QmuParserByteCode& QmuParserByteCode::operator=(const QmuParserByteCode &a_ByteC
return *this;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserByteCode::EnableOptimizer(bool bStat)
{
m_bEnableOptimizer = bStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy state of another object to this.
*
@ -94,7 +94,7 @@ void QmuParserByteCode::Assign(const QmuParserByteCode &a_ByteCode)
m_iMaxStackSize = a_ByteCode.m_iMaxStackSize;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a Variable pointer to bytecode.
* @param a_pVar Pointer to be added.
@ -114,7 +114,7 @@ void QmuParserByteCode::AddVar(qreal *a_pVar)
m_vRPN.push_back(tok);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a Variable pointer to bytecode.
*
@ -142,7 +142,7 @@ void QmuParserByteCode::AddVal(qreal a_fVal)
m_vRPN.push_back(tok);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserByteCode::ConstantFolding(ECmdCode a_Oprt)
{
std::size_t sz = m_vRPN.size();
@ -282,7 +282,7 @@ void QmuParserByteCode::ConstantFolding(ECmdCode a_Oprt)
} // switch opcode
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add an operator identifier to bytecode.
*
@ -526,7 +526,7 @@ void QmuParserByteCode::AddOp(ECmdCode a_Oprt)
}
// If optimization can't be applied just write the value
if (!bOptimized)
if (bOptimized == false)
{
--m_iStackPos;
SToken tok;
@ -535,7 +535,7 @@ void QmuParserByteCode::AddOp(ECmdCode a_Oprt)
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserByteCode::AddIfElse(ECmdCode a_Oprt)
{
SToken tok;
@ -543,7 +543,7 @@ void QmuParserByteCode::AddIfElse(ECmdCode a_Oprt)
m_vRPN.push_back(tok);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add an assignement operator
*
@ -565,7 +565,7 @@ void QmuParserByteCode::AddAssignOp(qreal *a_pVar)
m_vRPN.push_back(tok);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add function to bytecode.
*
@ -592,7 +592,7 @@ void QmuParserByteCode::AddFun(generic_fun_type a_pFun, int a_iArgc)
m_vRPN.push_back(tok);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add a bulk function to bytecode.
*
@ -611,7 +611,7 @@ void QmuParserByteCode::AddBulkFun(generic_fun_type a_pFun, int a_iArgc)
m_vRPN.push_back(tok);
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add Strung function entry to the parser bytecode.
* @throw nothrow
@ -633,7 +633,7 @@ void QmuParserByteCode::AddStrFun(generic_fun_type a_pFun, int a_iArgc, int a_iI
m_iMaxStackSize = qMax(m_iMaxStackSize, static_cast<size_t>(m_iStackPos));
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Add end marker to bytecode.
*
@ -770,7 +770,7 @@ void QmuParserByteCode::Finalize()
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
const SToken* QmuParserByteCode::GetBase() const
{
if (m_vRPN.size()==0)
@ -783,13 +783,13 @@ const SToken* QmuParserByteCode::GetBase() const
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
std::size_t QmuParserByteCode::GetMaxStackSize() const
{
return m_iMaxStackSize+1;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Returns the number of entries in the bytecode.
*/
@ -798,7 +798,7 @@ std::size_t QmuParserByteCode::GetSize() const
return m_vRPN.size();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Delete the bytecode.
*
@ -814,13 +814,13 @@ void QmuParserByteCode::clear()
m_iMaxStackSize = 0;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Dump bytecode (for debugging only!).
*/
void QmuParserByteCode::AsciiDump()
{
if (!m_vRPN.size())
if (m_vRPN.size() == false)
{
qDebug() << "No bytecode available\n";
return;

4
src/libs/qmuparser/qmuparserbytecode.h
View File

@ -39,7 +39,7 @@ struct SToken
ECmdCode Cmd;
int StackPos;
union
union //
{
struct //SValData
{
@ -122,5 +122,3 @@ public:
};
} // namespace qmu
#endif

74
src/libs/qmuparser/qmuparsercallback.cpp
View File

@ -29,7 +29,7 @@
namespace qmu
{
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
//Supressing specific warnings on gcc/g++ http://www.mr-edd.co.uk/blog/supressing_gcc_warnings
#ifdef __GNUC__
__extension__
@ -39,7 +39,7 @@ QmuParserCallback::QmuParserCallback ( fun_type0 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -49,7 +49,7 @@ QmuParserCallback::QmuParserCallback ( fun_type1 a_pFun, bool a_bAllowOpti, int
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor for constructing funcstion callbacks taking two arguments.
* @throw nothrow
@ -62,7 +62,7 @@ QmuParserCallback::QmuParserCallback ( fun_type2 a_pFun, bool a_bAllowOpti )
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
@ -80,7 +80,7 @@ QmuParserCallback::QmuParserCallback ( fun_type2 a_pFun, bool a_bAllowOpti, int
m_iCode ( cmOPRT_BIN ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -90,7 +90,7 @@ QmuParserCallback::QmuParserCallback ( fun_type3 a_pFun, bool a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -100,7 +100,7 @@ QmuParserCallback::QmuParserCallback ( fun_type4 a_pFun, bool a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -109,7 +109,7 @@ QmuParserCallback::QmuParserCallback ( fun_type5 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -118,7 +118,7 @@ QmuParserCallback::QmuParserCallback ( fun_type6 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -127,7 +127,7 @@ QmuParserCallback::QmuParserCallback ( fun_type7 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -136,7 +136,7 @@ QmuParserCallback::QmuParserCallback ( fun_type8 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -145,7 +145,7 @@ QmuParserCallback::QmuParserCallback ( fun_type9 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -154,7 +154,7 @@ QmuParserCallback::QmuParserCallback ( fun_type10 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -163,7 +163,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type0 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -172,7 +172,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type1 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor for constructing funcstion callbacks taking two arguments.
* @throw nothrow
@ -185,7 +185,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type2 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -194,7 +194,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type3 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -203,7 +203,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type4 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -212,7 +212,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type5 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -221,7 +221,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type6 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -230,7 +230,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type7 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -239,7 +239,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type8 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -248,7 +248,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type9 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -257,7 +257,7 @@ QmuParserCallback::QmuParserCallback ( bulkfun_type10 a_pFun, bool a_bAllowOpti
m_iCode ( cmFUNC_BULK ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -266,7 +266,7 @@ QmuParserCallback::QmuParserCallback ( multfun_type a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC ), m_iType ( tpDBL ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -275,7 +275,7 @@ QmuParserCallback::QmuParserCallback ( strfun_type1 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_STR ), m_iType ( tpSTR ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -284,7 +284,7 @@ QmuParserCallback::QmuParserCallback ( strfun_type2 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_STR ), m_iType ( tpSTR ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
#ifdef __GNUC__
__extension__
#endif
@ -293,7 +293,7 @@ QmuParserCallback::QmuParserCallback ( strfun_type3 a_pFun, bool a_bAllowOpti )
m_iCode ( cmFUNC_STR ), m_iType ( tpSTR ), m_bAllowOpti ( a_bAllowOpti )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Default constructor.
* @throw nothrow
@ -303,7 +303,7 @@ QmuParserCallback::QmuParserCallback()
m_bAllowOpti ( 0 )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy constructor.
* @throw nothrow
@ -321,7 +321,7 @@ QmuParserCallback::QmuParserCallback ( const QmuParserCallback &ref )
m_eOprtAsct = ref.m_eOprtAsct;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Clone this instance and return a pointer to the new instance.
*/
@ -330,7 +330,7 @@ QmuParserCallback* QmuParserCallback::Clone() const
return new QmuParserCallback ( *this );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return tru if the function is conservative.
*
@ -342,7 +342,7 @@ bool QmuParserCallback::IsOptimizable() const
return m_bAllowOpti;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Get the callback address for the parser function.
*
@ -356,7 +356,7 @@ void* QmuParserCallback::GetAddr() const
return m_pFun;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the callback code.
*/
@ -365,13 +365,13 @@ ECmdCode QmuParserCallback::GetCode() const
return m_iCode;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
ETypeCode QmuParserCallback::GetType() const
{
return m_iType;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the operator precedence.
* @throw nothrown
@ -383,7 +383,7 @@ int QmuParserCallback::GetPri() const
return m_iPri;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the operators associativity.
* @throw nothrown
@ -395,7 +395,7 @@ EOprtAssociativity QmuParserCallback::GetAssociativity() const
return m_eOprtAsct;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Returns the number of function Arguments.
*/

3
src/libs/qmuparser/qmuparsercallback.h
View File

@ -103,7 +103,7 @@ private:
bool m_bAllowOpti; ///< Flag indication optimizeability
};
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Container for Callback objects.
*/
@ -112,4 +112,3 @@ typedef std::map<QString, QmuParserCallback> funmap_type;
} // namespace qmu
#endif

1
src/libs/qmuparser/qmuparserdef.h
View File

@ -272,4 +272,3 @@ typedef qreal* ( *facfun_type ) ( const QString &, void* );
} // end of namespace
#endif

48
src/libs/qmuparser/qmuparsererror.cpp
View File

@ -28,23 +28,23 @@ namespace qmu
{
const QmuParserErrorMsg QmuParserErrorMsg::m_Instance;
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
const QmuParserErrorMsg& QmuParserErrorMsg::Instance()
{
return m_Instance;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QString QmuParserErrorMsg::operator[] ( unsigned a_iIdx ) const
{
return ( a_iIdx < static_cast<unsigned>( m_vErrMsg.size() ) ) ? m_vErrMsg[a_iIdx] : QString();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QmuParserErrorMsg::~QmuParserErrorMsg()
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QmuParserErrorMsg::QmuParserErrorMsg()
: m_vErrMsg ( 0 )
{
@ -90,7 +90,7 @@ QmuParserErrorMsg::QmuParserErrorMsg()
#if defined(_DEBUG)
for ( int i = 0; i < ecCOUNT; ++i )
{
if ( !m_vErrMsg[i].length() )
if ( m_vErrMsg[i].length() == false)
{
assert ( false );
}
@ -98,11 +98,11 @@ QmuParserErrorMsg::QmuParserErrorMsg()
#endif
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
//
// QParserError class
//
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Default constructor.
@ -113,7 +113,7 @@ QmuParserError::QmuParserError()
{
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief This Constructor is used for internal exceptions only.
*
@ -128,7 +128,7 @@ QmuParserError::QmuParserError ( EErrorCodes a_iErrc )
ReplaceSubString ( m_strMsg, "$TOK$", m_strTok );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Construct an error from a message text.
*/
@ -137,7 +137,7 @@ QmuParserError::QmuParserError ( const QString &sMsg )
m_ErrMsg ( QmuParserErrorMsg::Instance() )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Construct an error object.
* @param [in] a_iErrc the error code.
@ -157,7 +157,7 @@ QmuParserError::QmuParserError ( EErrorCodes iErrc,
ReplaceSubString ( m_strMsg, "$TOK$", m_strTok );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Construct an error object.
* @param [in] iErrc the error code.
@ -173,7 +173,7 @@ QmuParserError::QmuParserError ( EErrorCodes iErrc, int iPos, const QString &sTo
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.
@ -187,7 +187,7 @@ QmuParserError::QmuParserError ( const QString &szMsg, int iPos, const QString &
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 ),
@ -195,7 +195,7 @@ QmuParserError::QmuParserError ( const QmuParserError &a_Obj )
{
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/** @brief Assignment operator. */
QmuParserError& QmuParserError::operator= ( const QmuParserError &a_Obj )
{
@ -212,11 +212,11 @@ QmuParserError& QmuParserError::operator= ( const QmuParserError &a_Obj )
return *this;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QmuParserError::~QmuParserError()
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Replace all ocuurences of a substring with another string.
* @param strFind The string that shall be replaced.
@ -233,7 +233,9 @@ void QmuParserError::ReplaceSubString ( QString &strSource, const QString &strFi
strResult.append ( strSource.mid ( iPos, iNext - iPos ) );
if ( iNext == -1 )
{
break;
}
strResult.append ( strReplaceWith );
iPos = iNext + strFind.length();
@ -242,7 +244,7 @@ void QmuParserError::ReplaceSubString ( QString &strSource, const QString &strFi
strSource.swap ( strResult );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Reset the erro object.
*/
@ -255,7 +257,7 @@ void QmuParserError::Reset()
m_iErrc = ecUNDEFINED;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set the expression related to this error.
*/
@ -264,7 +266,7 @@ void QmuParserError::SetFormula ( const QString &a_strFormula )
m_strFormula = a_strFormula;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief gets the expression related tp this error.
*/
@ -273,7 +275,7 @@ const QString& QmuParserError::GetExpr() const
return m_strFormula;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Returns the message string for this error.
*/
@ -282,7 +284,7 @@ const QString& QmuParserError::GetMsg() const
return m_strMsg;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the formula position related to the error.
*
@ -293,7 +295,7 @@ std::size_t QmuParserError::GetPos() const
return m_iPos;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return string related with this token (if available).
*/
@ -302,7 +304,7 @@ const QString& QmuParserError::GetToken() const
return m_strTok;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the error code.
*/

1
src/libs/qmuparser/qmuparsererror.h
View File

@ -155,4 +155,3 @@ private:
} // namespace qmu
#endif

2
src/libs/qmuparser/qmuparserfixes.h
View File

@ -55,5 +55,3 @@
#endif
#endif // include guard

46
src/libs/qmuparser/qmuparsertest.cpp
View File

@ -41,7 +41,7 @@ namespace Test
{
int QmuParserTester::c_iCount = 0;
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QmuParserTester::QmuParserTester()
: m_vTestFun()
{
@ -61,7 +61,7 @@ QmuParserTester::QmuParserTester()
QmuParserTester::c_iCount = 0;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::IsHexVal ( const QString &a_szExpr, int *a_iPos, qreal *a_fVal )
{
if ( a_szExpr[1] == 0 || ( a_szExpr[0] != '0' || a_szExpr[1] != 'x' ) )
@ -92,7 +92,7 @@ int QmuParserTester::IsHexVal ( const QString &a_szExpr, int *a_iPos, qreal *a_f
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestInterface()
{
int iStat = 0;
@ -138,7 +138,7 @@ int QmuParserTester::TestInterface()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestStrArg()
{
int iStat = 0;
@ -167,7 +167,7 @@ int QmuParserTester::TestStrArg()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestBinOprt()
{
int iStat = 0;
@ -242,7 +242,7 @@ int QmuParserTester::TestBinOprt()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/** @brief Check muParser name restriction enforcement. */
int QmuParserTester::TestNames()
{
@ -355,7 +355,7 @@ int QmuParserTester::TestNames()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestSyntax()
{
int iStat = 0;
@ -408,7 +408,7 @@ int QmuParserTester::TestSyntax()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestVarConst()
{
int iStat = 0;
@ -541,7 +541,7 @@ int QmuParserTester::TestVarConst()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestMultiArg()
{
int iStat = 0;
@ -640,7 +640,7 @@ int QmuParserTester::TestMultiArg()
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestInfixOprt()
{
int iStat ( 0 );
@ -709,7 +709,7 @@ int QmuParserTester::TestInfixOprt()
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestPostFix()
{
int iStat = 0;
@ -764,7 +764,7 @@ int QmuParserTester::TestPostFix()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestExpression()
{
int iStat = 0;
@ -849,9 +849,7 @@ int QmuParserTester::TestExpression()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestIfThenElse()
{
int iStat = 0;
@ -961,7 +959,7 @@ int QmuParserTester::TestIfThenElse()
return iStat;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::TestException()
{
int iStat = 0;
@ -1060,13 +1058,13 @@ int QmuParserTester::TestException()
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserTester::AddTest ( testfun_type a_pFun )
{
m_vTestFun.push_back ( a_pFun );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserTester::Run()
{
int iStat = 0;
@ -1108,7 +1106,7 @@ void QmuParserTester::Run()
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int QmuParserTester::ThrowTest ( const QString &a_str, int a_iErrc, bool a_bFail )
{
QmuParserTester::c_iCount++;
@ -1157,7 +1155,7 @@ int QmuParserTester::ThrowTest ( const QString &a_str, int a_iErrc, bool a_bFail
return bRet;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Evaluate a tet expression.
*
@ -1213,7 +1211,7 @@ int QmuParserTester::EqnTestWithVarChange ( const QString &a_str, double a_fVar1
return 0;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Evaluate a tet expression.
*
@ -1358,7 +1356,7 @@ int QmuParserTester::EqnTest ( const QString &a_str, double a_fRes, bool a_fPass
}
}
iRet = ( ( bCloseEnough && a_fPass ) || ( !bCloseEnough && !a_fPass ) ) ? 0 : 1;
iRet = ( ( bCloseEnough && a_fPass ) || ( bCloseEnough == false && a_fPass == false) ) ? 0 : 1;
if ( iRet == 1 )
@ -1402,14 +1400,14 @@ int QmuParserTester::EqnTest ( const QString &a_str, double a_fRes, bool a_fPass
return iRet;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Internal error in test class Test is going to be aborted.
*/
void Q_NORETURN QmuParserTester::Abort() const
{
qDebug() << "Test failed (internal error in test class)";
while ( !getchar() );
while ( getchar() == false);
exit ( -1 );
}
} // namespace test

10
src/libs/qmuparser/qmuparsertest.h
View File

@ -41,7 +41,7 @@ namespace qmu
*/
namespace Test
{
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Test cases for unit testing.
*
@ -183,7 +183,7 @@ private:
static qreal FirstArg ( const qreal* a_afArg, int a_iArgc )
{
if ( !a_iArgc )
if ( a_iArgc == false)
{
throw qmu::QmuParser::exception_type ( "too few arguments for function FirstArg." );
}
@ -193,7 +193,7 @@ private:
static qreal LastArg ( const qreal* a_afArg, int a_iArgc )
{
if ( !a_iArgc )
if ( a_iArgc == false)
{
throw qmu::QmuParser::exception_type ( "too few arguments for function LastArg." );
}
@ -203,7 +203,7 @@ private:
static qreal Sum ( const qreal* a_afArg, int a_iArgc )
{
if ( !a_iArgc )
if ( a_iArgc == false)
{
throw qmu::QmuParser::exception_type ( "too few arguments for function sum." );
}
@ -298,5 +298,3 @@ private:
} // namespace qmu
#endif

16
src/libs/qmuparser/qmuparsertoken.h
View File

@ -237,7 +237,9 @@ public:
void SetIdx ( int a_iIdx )
{
if ( m_iCode != cmSTRING || a_iIdx < 0 )
{
throw QmuParserError ( ecINTERNAL_ERROR );
}
m_iIdx = a_iIdx;
}
@ -254,7 +256,9 @@ public:
int GetIdx() const
{
if ( m_iIdx < 0 || m_iCode != cmSTRING )
{
throw QmuParserError ( ecINTERNAL_ERROR );
}
return m_iIdx;
}
@ -294,11 +298,15 @@ public:
//------------------------------------------------------------------------------
int GetPri() const
{
if ( !m_pCallback.get() )
if ( m_pCallback.get() == false)
{
throw QmuParserError ( ecINTERNAL_ERROR );
}
if ( m_pCallback->GetCode() != cmOPRT_BIN && m_pCallback->GetCode() != cmOPRT_INFIX )
{
throw QmuParserError ( ecINTERNAL_ERROR );
}
return m_pCallback->GetPri();
}
@ -307,7 +315,9 @@ public:
EOprtAssociativity GetAssociativity() const
{
if ( m_pCallback.get() == NULL || m_pCallback->GetCode() != cmOPRT_BIN )
{
throw QmuParserError ( ecINTERNAL_ERROR );
}
return m_pCallback->GetAssociativity();
}
@ -482,8 +492,10 @@ public:
{
assert ( m_pCallback.get() );
if ( !m_pCallback->GetAddr() )
if ( m_pCallback->GetAddr() == false)
{
throw QmuParserError ( ecINTERNAL_ERROR );
}
return m_pCallback->GetArgc();
}

225
src/libs/qmuparser/qmuparsertokenreader.cpp
View File

@ -36,7 +36,7 @@ namespace qmu
// Forward declaration
class QmuParserBase;
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Copy constructor.
*
@ -54,7 +54,7 @@ QmuParserTokenReader::QmuParserTokenReader ( const QmuParserTokenReader &a_Reade
m_cArgSep( a_Reader.m_cArgSep )
{}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Assignement operator.
*
@ -73,7 +73,7 @@ QmuParserTokenReader& QmuParserTokenReader::operator= ( const QmuParserTokenRead
return *this;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Assign state of a token reader to this token reader.
*
@ -103,7 +103,7 @@ void QmuParserTokenReader::Assign ( const QmuParserTokenReader &a_Reader )
m_cArgSep = a_Reader.m_cArgSep;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Constructor.
*
@ -123,7 +123,7 @@ QmuParserTokenReader::QmuParserTokenReader ( QmuParserBase *a_pParent )
SetParent ( m_pParser );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Create instance of a QParserTokenReader identical with this and return its pointer.
*
@ -139,14 +139,14 @@ QmuParserTokenReader* QmuParserTokenReader::Clone ( QmuParserBase *a_pParent ) c
return ptr.release();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QmuParserTokenReader::token_type& QmuParserTokenReader::SaveBeforeReturn ( const token_type &tok )
{
m_lastTok = tok;
return m_lastTok;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserTokenReader::AddValIdent ( identfun_type a_pCallback )
{
// Use push_front is used to give user defined callbacks a higher priority than
@ -158,14 +158,14 @@ void QmuParserTokenReader::AddValIdent ( identfun_type a_pCallback )
m_vIdentFun.push_front ( a_pCallback );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserTokenReader::SetVarCreator ( facfun_type a_pFactory, void *pUserData )
{
m_pFactory = a_pFactory;
m_pFactoryData = pUserData;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return the current position of the token reader in the formula string.
*
@ -177,7 +177,7 @@ int QmuParserTokenReader::GetPos() const
return m_iPos;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return a reference to the formula.
*
@ -189,7 +189,7 @@ const QString& QmuParserTokenReader::GetExpr() const
return m_strFormula;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return a map containing the used variables only.
*/
@ -198,7 +198,7 @@ varmap_type& QmuParserTokenReader::GetUsedVar()
return m_UsedVar;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Initialize the token Reader.
*
@ -211,7 +211,7 @@ void QmuParserTokenReader::SetFormula ( const QString &a_strFormula )
ReInit();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Set Flag that contronls behaviour in case of undefined variables beeing found.
*
@ -225,7 +225,7 @@ void QmuParserTokenReader::IgnoreUndefVar ( bool bIgnore )
m_bIgnoreUndefVar = bIgnore;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Reset the token reader to the start of the formula.
*
@ -243,7 +243,7 @@ void QmuParserTokenReader::ReInit()
m_lastTok = token_type();
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Read the next token from the string.
*/
@ -264,17 +264,50 @@ QmuParserTokenReader::token_type QmuParserTokenReader::ReadNextToken()
++m_iPos;
}
if ( IsEOF ( tok ) ) return SaveBeforeReturn ( tok ); // Check for end of formula
if ( IsOprt ( tok ) ) return SaveBeforeReturn ( tok ); // Check for user defined binary operator
if ( IsFunTok ( tok ) ) return SaveBeforeReturn ( tok ); // Check for function token
if ( IsBuiltIn ( tok ) ) return SaveBeforeReturn ( tok ); // Check built in operators / tokens
if ( IsArgSep ( tok ) ) return SaveBeforeReturn ( tok ); // Check for function argument separators
if ( IsValTok ( tok ) ) return SaveBeforeReturn ( tok ); // Check for values / constant tokens
if ( IsVarTok ( tok ) ) return SaveBeforeReturn ( tok ); // Check for variable tokens
if ( IsStrVarTok ( tok ) ) return SaveBeforeReturn ( tok ); // Check for string variables
if ( IsString ( tok ) ) return SaveBeforeReturn ( tok ); // Check for String tokens
if ( IsInfixOpTok ( tok ) ) return SaveBeforeReturn ( tok ); // Check for unary operators
if ( IsPostOpTok ( tok ) ) return SaveBeforeReturn ( tok ); // Check for unary operators
if ( IsEOF ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for end of formula
}
if ( IsOprt ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for user defined binary operator
}
if ( IsFunTok ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for function token
}
if ( IsBuiltIn ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check built in operators / tokens
}
if ( IsArgSep ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for function argument separators
}
if ( IsValTok ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for values / constant tokens
}
if ( IsVarTok ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for variable tokens
}
if ( IsStrVarTok ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for string variables
}
if ( IsString ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for String tokens
}
if ( IsInfixOpTok ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for unary operators
}
if ( IsPostOpTok ( tok ) )
{
return SaveBeforeReturn ( tok ); // Check for unary operators
}
// Check String for undefined variable token. Done only if a
// flag is set indicating to ignore undefined variables.
@ -303,7 +336,7 @@ QmuParserTokenReader::token_type QmuParserTokenReader::ReadNextToken()
return token_type(); // never reached
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserTokenReader::SetParent ( QmuParserBase *a_pParent )
{
m_pParser = a_pParent;
@ -316,7 +349,7 @@ void QmuParserTokenReader::SetParent ( QmuParserBase *a_pParent )
m_pConstDef = &a_pParent->m_ConstDef;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Extract all characters that belong to a certain charset.
*
@ -347,16 +380,18 @@ int QmuParserTokenReader::ExtractToken ( const QString &a_szCharSet, QString &a_
if ( a_iPos != iEnd )
{
#if defined(_UNICODE)
a_sTok = QString().fromStdWString ( std::wstring ( m_strFormulaStd.begin() + a_iPos, m_strFormulaStd.begin() + iEnd ) );
a_sTok = QString().fromStdWString ( std::wstring ( m_strFormulaStd.begin() + a_iPos,
m_strFormulaStd.begin() + iEnd ) );
#else
a_sTok = QString().fromStdString ( std::string ( m_strFormulaStd.begin() + a_iPos, m_strFormulaStd.begin() + iEnd ) );
a_sTok = QString().fromStdString ( std::string ( m_strFormulaStd.begin() + a_iPos,
m_strFormulaStd.begin() + iEnd ) );
#endif
}
return iEnd;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check Expression for the presence of a binary operator token.
*
@ -386,7 +421,8 @@ int QmuParserTokenReader::ExtractOperatorToken ( QString &a_sTok, int a_iPos ) c
a_sTok = QString().fromStdWString ( string_type ( m_strFormulaStd.begin() + a_iPos,
m_strFormulaStd.begin() + iEnd ) );
#else
a_sTok = QString().fromStdString ( string_type ( m_strFormulaStd.begin() + a_iPos, m_strFormulaStd.begin() + iEnd ) );
a_sTok = QString().fromStdString ( string_type ( m_strFormulaStd.begin() + a_iPos,
m_strFormulaStd.begin() + iEnd ) );
#endif
return iEnd;
}
@ -398,7 +434,7 @@ int QmuParserTokenReader::ExtractOperatorToken ( QString &a_sTok, int a_iPos ) c
}
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a built in operator or other token can be found
* @param a_Tok [out] Operator token if one is found. This can either be a binary operator or an infix operator token.
@ -439,16 +475,23 @@ bool QmuParserTokenReader::IsBuiltIn ( token_type &a_Tok )
// The assignement operator need special treatment
if ( i == cmASSIGN && m_iSynFlags & noASSIGN )
{
Error ( ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef.at ( i ) );
}
if ( !m_pParser->HasBuiltInOprt() ) continue;
if ( m_pParser->HasBuiltInOprt() == false)
{
continue;
}
if ( m_iSynFlags & noOPT )
{
// Maybe its an infix operator not an operator
// Both operator types can share characters in
// their identifiers
if ( IsInfixOpTok ( a_Tok ) )
{
return true;
}
Error ( ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef.at ( i ) );
}
@ -459,36 +502,50 @@ bool QmuParserTokenReader::IsBuiltIn ( token_type &a_Tok )
case cmBO:
if ( m_iSynFlags & noBO )
{
Error ( ecUNEXPECTED_PARENS, m_iPos, pOprtDef.at ( i ) );
}
if ( m_lastTok.GetCode() == cmFUNC )
{
m_iSynFlags = noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE;
}
else
{
m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE;
}
++m_iBrackets;
break;
case cmBC:
if ( m_iSynFlags & noBC )
{
Error ( ecUNEXPECTED_PARENS, m_iPos, pOprtDef.at ( i ) );
}
m_iSynFlags = noBO | noVAR | noVAL | noFUN | noINFIXOP | noSTR | noASSIGN;
if ( --m_iBrackets < 0 )
{
Error ( ecUNEXPECTED_PARENS, m_iPos, pOprtDef.at ( i ) );
}
break;
case cmELSE:
if ( m_iSynFlags & noELSE )
{
Error ( ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef.at ( i ) );
}
m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE;
break;
case cmIF:
if ( m_iSynFlags & noIF )
{
Error ( ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef.at ( i ) );
}
m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE;
break;
@ -506,7 +563,7 @@ bool QmuParserTokenReader::IsBuiltIn ( token_type &a_Tok )
return false;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
bool QmuParserTokenReader::IsArgSep ( token_type &a_Tok )
{
if ( m_strFormula.at ( m_iPos ) == m_cArgSep )
@ -530,7 +587,7 @@ bool QmuParserTokenReader::IsArgSep ( token_type &a_Tok )
return false;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check for End of Formula.
*
@ -548,13 +605,17 @@ bool QmuParserTokenReader::IsEOF ( token_type &a_Tok )
#endif
// check for EOF
if ( !szFormula[m_iPos] /*|| szFormula[m_iPos] == '\n'*/ )
if ( szFormula[m_iPos] == false /*|| szFormula[m_iPos] == '\n'*/ )
{
if ( m_iSynFlags & noEND )
{
Error ( ecUNEXPECTED_EOF, m_iPos );
}
if ( m_iBrackets > 0 )
{
Error ( ecMISSING_PARENS, m_iPos, ")" );
}
m_iSynFlags = 0;
a_Tok.Set ( cmEND );
@ -564,7 +625,7 @@ bool QmuParserTokenReader::IsEOF ( token_type &a_Tok )
return false;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a string position contains a unary infix operator.
* @return true if a function token has been found false otherwise.
@ -574,20 +635,26 @@ bool QmuParserTokenReader::IsInfixOpTok ( token_type &a_Tok )
QString sTok;
int iEnd = ExtractToken ( m_pParser->ValidInfixOprtChars(), sTok, m_iPos );
if ( iEnd == m_iPos )
{
return false;
}
// iteraterate over all postfix operator strings
funmap_type::const_reverse_iterator it = m_pInfixOprtDef->rbegin();
for ( ; it != m_pInfixOprtDef->rend(); ++it )
{
if ( sTok.indexOf ( it->first ) != 0 )
{
continue;
}
a_Tok.Set ( it->second, it->first );
m_iPos += static_cast<int>(it->first.length());
if ( m_iSynFlags & noINFIXOP )
{
Error ( ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString() );
}
m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN;
return true;
@ -607,7 +674,7 @@ bool QmuParserTokenReader::IsInfixOpTok ( token_type &a_Tok )
*/
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check whether the token at a given position is a function token.
* @param a_Tok [out] If a value token is found it will be placed here.
@ -620,27 +687,35 @@ bool QmuParserTokenReader::IsFunTok ( token_type &a_Tok )
QString strTok;
int iEnd = ExtractToken ( m_pParser->ValidNameChars(), strTok, m_iPos );
if ( iEnd == m_iPos )
{
return false;
}
funmap_type::const_iterator item = m_pFunDef->find ( strTok );
if ( item == m_pFunDef->end() )
{
return false;
}
// Check if the next sign is an opening bracket
if ( m_strFormula.at ( iEnd ) != '(' )
{
return false;
}
a_Tok.Set ( item->second, strTok );
m_iPos = iEnd;
if ( m_iSynFlags & noFUN )
{
Error ( ecUNEXPECTED_FUN, m_iPos - static_cast<int>(a_Tok.GetAsString().length()), a_Tok.GetAsString() );
}
m_iSynFlags = noANY ^ noBO;
return true;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a string position contains a binary operator.
* @param a_Tok [out] Operator token if one is found. This can either be a binary operator or an infix operator token.
@ -652,7 +727,9 @@ bool QmuParserTokenReader::IsOprt ( token_type &a_Tok )
int iEnd = ExtractOperatorToken ( strTok, m_iPos );
if ( iEnd == m_iPos )
{
return false;
}
// Check if the operator is a built in operator, if so ignore it here
const QStringList pOprtDef = m_pParser->GetOprtDef();
@ -661,8 +738,10 @@ bool QmuParserTokenReader::IsOprt ( token_type &a_Tok )
++constIterator )
{
if ( ( *constIterator ) == strTok )
{
return false;
}
}
// Note:
// All tokens in oprt_bin_maptype are have been sorted by their length
@ -686,7 +765,9 @@ bool QmuParserTokenReader::IsOprt ( token_type &a_Tok )
// operator, not a binary operator. Both operator types
// can share characters in their identifiers.
if ( IsInfixOpTok ( a_Tok ) )
{
return true;
}
else
{
// nope, no infix operator
@ -705,7 +786,7 @@ bool QmuParserTokenReader::IsOprt ( token_type &a_Tok )
return false;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check if a string position contains a unary post value operator.
*/
@ -719,7 +800,9 @@ bool QmuParserTokenReader::IsPostOpTok ( token_type &a_Tok )
// http://sourceforge.net/tracker/index.php?func=detail&aid=3343891&group_id=137191&atid=737979
//
if ( m_iSynFlags & noPOSTOP )
{
return false;
}
// </ibg>
// Tricky problem with equations like "3m+5":
@ -734,14 +817,18 @@ bool QmuParserTokenReader::IsPostOpTok ( token_type &a_Tok )
QString sTok;
int iEnd = ExtractToken ( m_pParser->ValidOprtChars(), sTok, m_iPos );
if ( iEnd == m_iPos )
{
return false;
}
// iteraterate over all postfix operator strings
funmap_type::const_reverse_iterator it = m_pPostOprtDef->rbegin();
for ( ; it != m_pPostOprtDef->rend(); ++it )
{
if ( sTok.indexOf ( it->first ) != 0 )
{
continue;
}
a_Tok.Set ( it->second, sTok );
m_iPos += it->first.length();
@ -753,7 +840,7 @@ bool QmuParserTokenReader::IsPostOpTok ( token_type &a_Tok )
return false;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check whether the token at a given position is a value token.
*
@ -783,7 +870,9 @@ bool QmuParserTokenReader::IsValTok ( token_type &a_Tok )
a_Tok.SetVal ( item->second, strTok );
if ( m_iSynFlags & noVAL )
{
Error ( ecUNEXPECTED_VAL, m_iPos - strTok.length(), strTok );
}
m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN;
return true;
@ -800,7 +889,9 @@ bool QmuParserTokenReader::IsValTok ( token_type &a_Tok )
{
strTok = m_strFormula.mid ( iStart, m_iPos );
if ( m_iSynFlags & noVAL )
{
Error ( ecUNEXPECTED_VAL, m_iPos - strTok.length(), strTok );
}
a_Tok.SetVal ( fVal, strTok );
m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN;
@ -811,7 +902,7 @@ bool QmuParserTokenReader::IsValTok ( token_type &a_Tok )
return false;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check wheter a token at a given position is a variable token.
* @param a_Tok [out] If a variable token has been found it will be placed here.
@ -819,20 +910,28 @@ bool QmuParserTokenReader::IsValTok ( token_type &a_Tok )
*/
bool QmuParserTokenReader::IsVarTok ( token_type &a_Tok )
{
if ( !m_pVarDef->size() )
if ( m_pVarDef->size() == false)
{
return false;
}
QString strTok;
int iEnd = ExtractToken ( m_pParser->ValidNameChars(), strTok, m_iPos );
if ( iEnd == m_iPos )
{
return false;
}
varmap_type::const_iterator item = m_pVarDef->find ( strTok );
if ( item == m_pVarDef->end() )
{
return false;
}
if ( m_iSynFlags & noVAR )
{
Error ( ecUNEXPECTED_VAR, m_iPos, strTok );
}
m_pParser->OnDetectVar ( m_strFormula, m_iPos, iEnd );
@ -847,27 +946,37 @@ bool QmuParserTokenReader::IsVarTok ( token_type &a_Tok )
return true;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
bool QmuParserTokenReader::IsStrVarTok ( token_type &a_Tok )
{
if ( !m_pStrVarDef || !m_pStrVarDef->size() )
if ( m_pStrVarDef == false || m_pStrVarDef->size() == false)
{
return false;
}
QString strTok;
int iEnd = ExtractToken ( m_pParser->ValidNameChars(), strTok, m_iPos );
if ( iEnd == m_iPos )
{
return false;
}
strmap_type::const_iterator item = m_pStrVarDef->find ( strTok );
if ( item == m_pStrVarDef->end() )
{
return false;
}
if ( m_iSynFlags & noSTR )
{
Error ( ecUNEXPECTED_VAR, m_iPos, strTok );
}
m_iPos = iEnd;
if ( !m_pParser->m_vStringVarBuf.size() )
if ( m_pParser->m_vStringVarBuf.size() == false)
{
Error ( ecINTERNAL_ERROR );
}
a_Tok.SetString ( m_pParser->m_vStringVarBuf[item->second], m_pParser->m_vStringVarBuf.size() );
@ -876,7 +985,7 @@ bool QmuParserTokenReader::IsStrVarTok ( token_type &a_Tok )
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check wheter a token at a given position is an undefined variable.
*
@ -931,7 +1040,7 @@ bool QmuParserTokenReader::IsUndefVarTok ( token_type &a_Tok )
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Check wheter a token at a given position is a string.
* @param a_Tok [out] If a variable token has been found it will be placed here.
@ -942,7 +1051,9 @@ bool QmuParserTokenReader::IsUndefVarTok ( token_type &a_Tok )
bool QmuParserTokenReader::IsString ( token_type &a_Tok )
{
if ( m_strFormula[m_iPos] != '"' )
{
return false;
}
QString strBuf ( m_strFormula[m_iPos + 1] );
int iEnd ( 0 ), iSkip ( 0 );
@ -950,18 +1061,25 @@ bool QmuParserTokenReader::IsString ( token_type &a_Tok )
// parser over escaped '\"' end replace them with '"'
for ( iEnd = strBuf.indexOf ( "\"" ); iEnd != 0 && iEnd != -1; iEnd = strBuf.indexOf ( "\"", iEnd ) )
{
if ( strBuf[iEnd - 1] != '\\' ) break;
if ( strBuf[iEnd - 1] != '\\' )
{
break;
}
strBuf.replace ( iEnd - 1, 2, "\"" );
iSkip++;
}
if ( iEnd == -1 )
{
Error ( ecUNTERMINATED_STRING, m_iPos, "\"" );
}
QString strTok = strBuf.mid ( 0, iEnd );
if ( m_iSynFlags & noSTR )
{
Error ( ecUNEXPECTED_STR, m_iPos, strTok );
}
m_pParser->m_vStringBuf.push_back ( strTok ); // Store string in internal buffer
a_Tok.SetString ( strTok, m_pParser->m_vStringBuf.size() );
@ -972,7 +1090,7 @@ bool QmuParserTokenReader::IsString ( token_type &a_Tok )
return true;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Create an error containing the parse error position.
*
@ -988,16 +1106,15 @@ void QmuParserTokenReader::Error ( EErrorCodes a_iErrc, int a_iPos, const QStri
m_pParser->Error ( a_iErrc, a_iPos, a_sTok );
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
void QmuParserTokenReader::SetArgSep ( char_type cArgSep )
{
m_cArgSep = cArgSep;
}
//----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
QChar QmuParserTokenReader::GetArgSep() const
{
return m_cArgSep;
}
} // namespace qmu

14
src/libs/qmuparser/qmuparsertokenreader.h
View File

@ -74,12 +74,12 @@ namespace qmu
token_type ReadNextToken();
private:
/** @brief Syntax codes.
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
if certain tokens are identified.
/**
* @brief Syntax codes.
*
* 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
* if certain tokens are identified.
*/
enum ESynCodes
{
@ -152,5 +152,3 @@ namespace qmu
} // namespace qmu
#endif