From 83066edec074772d98a239a1d42d0088dc9bc8b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Marjam=C3=A4ki?= <daniel.marjamaki@gmail.com>
Date: Tue, 10 Dec 2013 06:29:06 +0100
Subject: [PATCH] Code cleanup
---
lib/checkother.cpp | 238 ---------------------------------------------
lib/checkother.h | 10 --
2 files changed, 248 deletions(-)
diff --git a/lib/checkother.cpp b/lib/checkother.cpp
index 11e199fd8..3da00b0d8 100644
--- a/lib/checkother.cpp
+++ b/lib/checkother.cpp
@@ -1249,13 +1249,6 @@ void CheckOther::selfAssignmentError(const Token *tok, const std::string &varnam
// Inform that second comparison is always true when first comparison is true.
//---------------------------------------------------------------------------
-enum Position { First, Second, NA };
-enum Relation { Equal, NotEqual, Less, LessEqual, More, MoreEqual };
-struct Condition {
- Position position;
- const char *opTokStr;
-};
-
static std::string invertOperatorForOperandSwap(std::string s)
{
for (std::string::size_type i = 0; i < s.length(); i++) {
@@ -2863,111 +2856,6 @@ void CheckOther::doubleCloseDirError(const Token *tok, const std::string &varnam
}
namespace {
- struct ExpressionTokens {
- const Token *start;
- const Token *end;
- int count;
- bool inconclusiveFunction;
- ExpressionTokens(const Token *s, const Token *e): start(s), end(e), count(1), inconclusiveFunction(false) {}
- };
-
- struct FuncFilter {
- FuncFilter(const Scope *scope, const Token *tok): _scope(scope), _tok(tok) {}
-
- bool operator()(const Function* func) const {
- bool matchingFunc = func->type == Function::eFunction &&
- _tok->str() == func->token->str();
- // either a class function, or a global function with the same name
- return (_scope && _scope == func->nestedIn && matchingFunc) ||
- (!_scope && matchingFunc);
- }
- const Scope *_scope;
- const Token *_tok;
- };
-
- bool inconclusiveFunctionCall(const std::list<const Function*> &constFunctions,
- const ExpressionTokens &tokens)
- {
- const Token *start = tokens.start;
- const Token *end = tokens.end;
- // look for function calls between start and end...
- for (const Token *tok = start; tok && tok != end; tok = tok->next()) {
- if (tok != start && tok->str() == "(") {
- // go back to find the function call.
- const Token *prev = tok->previous();
- if (!prev)
- continue;
- if (prev->str() == ">") {
- // ignore template functions like boo<double>()
- return true;
- }
- if (prev->isName()) {
- const Variable *v = 0;
- if (Token::Match(prev->tokAt(-2), "%var% .")) {
- const Token *scope = prev->tokAt(-2);
- v = scope->variable();
- }
- // hard coded list of safe, no-side-effect functions
- if (v == 0 && Token::Match(prev, "strcmp|strncmp|strlen|wcscmp|wcsncmp|wcslen|memcmp|strcasecmp|strncasecmp"))
- return false;
- std::list<const Function*>::const_iterator it = std::find_if(constFunctions.begin(),
- constFunctions.end(),
- FuncFilter(v ? v->typeScope(): 0, prev));
- if (it == constFunctions.end())
- return true;
- }
- }
- }
- return false;
- }
-
- class Expressions {
- public:
- Expressions(const std::list<const Function*> &constFunctions)
- : _start(0),
- _lastTokens(0),
- _constFunctions(constFunctions) { }
-
- void endExpr(const Token *end) {
- const std::string &e = _expression.str();
- if (!e.empty()) {
- std::map<std::string, ExpressionTokens>::iterator it = _expressions.find(e);
- bool lastInconclusive = _lastTokens && _lastTokens->inconclusiveFunction;
- if (it == _expressions.end()) {
- ExpressionTokens exprTokens(_start, end);
- exprTokens.inconclusiveFunction = lastInconclusive || inconclusiveFunctionCall(
- _constFunctions, exprTokens);
- _expressions.insert(std::make_pair(e, exprTokens));
- _lastTokens = &_expressions.find(e)->second;
- } else {
- ExpressionTokens &expr = it->second;
- expr.count += 1;
- expr.inconclusiveFunction = expr.inconclusiveFunction || lastInconclusive;
- _lastTokens = &expr;
- }
- }
- _expression.str("");
- _start = 0;
- }
-
- void append(const Token *tok) {
- if (!_start)
- _start = tok;
- _expression << tok->str();
- }
-
- std::map<std::string,ExpressionTokens> &getMap() {
- return _expressions;
- }
-
- private:
- std::map<std::string, ExpressionTokens> _expressions;
- std::ostringstream _expression;
- const Token *_start;
- ExpressionTokens *_lastTokens;
- const std::list<const Function*> &_constFunctions;
- };
-
bool notconst(const Function* func)
{
return !func->isConst;
@@ -2995,132 +2883,6 @@ namespace {
}
}
}
-
-}
-
-void CheckOther::checkExpressionRange(const std::list<const Function*> &constFunctions,
- const Token *start,
- const Token *end,
- const std::string &toCheck)
-{
- if (!start || !end)
- return;
- Expressions expressions(constFunctions);
- std::string opName;
- int level = 0;
- for (const Token *tok = start->next(); tok && tok != end; tok = tok->next()) {
- if (tok->str() == ")")
- level--;
- else if (tok->str() == "(")
- level++;
-
- if (level == 0 && Token::Match(tok, toCheck.c_str())) {
- opName = tok->str();
- expressions.endExpr(tok);
- } else {
- expressions.append(tok);
- }
- }
- expressions.endExpr(end);
- std::map<std::string,ExpressionTokens>::const_iterator it = expressions.getMap().begin();
- for (; it != expressions.getMap().end(); ++it) {
- // check expression..
- bool valid = true;
- unsigned int parentheses = 0; // ()
- unsigned int brackets = 0; // []
-
- // taking address?
- if (Token::Match(it->second.end->previous(), "%op% &")) {
- continue;
- }
-
- for (const Token *tok = it->second.start; tok && tok != it->second.end; tok = tok->next()) {
- if (tok->str() == "(") {
- ++parentheses;
- } else if (tok->str() == ")") {
- if (parentheses == 0) {
- valid = false;
- break;
- }
- --parentheses;
- } else if (tok->str() == "[") {
- ++brackets;
- } else if (tok->str() == "]") {
- if (brackets == 0) {
- valid = false;
- break;
- }
- --brackets;
- } else if (tok->type() == Token::eIncDecOp) {
- valid = false;
- break;
- }
- }
-
- if (!valid || parentheses!=0 || brackets!=0)
- continue;
-
- const ExpressionTokens &expr = it->second;
- if (expr.count > 1 && !expr.inconclusiveFunction) {
- duplicateExpressionError(expr.start, expr.start, opName);
- }
- }
-}
-
-void CheckOther::complexDuplicateExpressionCheck(const std::list<const Function*> &constFunctions,
- const Token *classStart,
- const std::string &toCheck,
- const std::string &alt)
-{
- std::string statementStart(",|=|?|:|return");
- if (!alt.empty())
- statementStart += "|" + alt;
- std::string statementEnd(";|,|?|:");
- if (!alt.empty())
- statementEnd += "|" + alt;
-
- for (const Token *tok = classStart; tok && tok != classStart->link(); tok = tok->next()) {
- if (!Token::Match(tok, toCheck.c_str()))
- continue;
-
- // look backward for the start of the statement
- const Token *start = 0;
- int level = 0;
- for (const Token *tok1 = tok->previous(); tok1 && tok1 != classStart; tok1 = tok1->previous()) {
- if (tok1->str() == ")")
- level++;
- else if (tok1->str() == "(")
- level--;
-
- if (level < 0 || (level == 0 && Token::Match(tok1, statementStart.c_str()))) {
- start = tok1;
- break;
- }
-
- if (tok1->isExpandedMacro())
- break;
- }
- const Token *end = 0;
- level = 0;
- // look for the end of the statement
- for (const Token *tok1 = tok->next(); tok1 && tok1 != classStart->link(); tok1 = tok1->next()) {
- if (tok1->str() == ")")
- level--;
- else if (tok1->str() == "(")
- level++;
-
- if (level < 0 || (level == 0 && Token::Match(tok1, statementEnd.c_str()))) {
- end = tok1;
- break;
- }
-
- if (tok1->isExpandedMacro())
- break;
- }
-
- if (start && end)
- checkExpressionRange(constFunctions, start, end, toCheck);
- }
}
static bool astIsFloat(const Token *tok)
diff --git a/lib/checkother.h b/lib/checkother.h
index dcf4f3f9b..c4cab33c2 100644
--- a/lib/checkother.h
+++ b/lib/checkother.h
@@ -470,16 +470,6 @@ private:
"* NaN (not a number) value used in arithmetic expression.\n"
"* comma in return statement (the comma can easily be misread as a semicolon).\n";
}
-
- void checkExpressionRange(const std::list<const Function*> &constFunctions,
- const Token *start,
- const Token *end,
- const std::string &toCheck);
-
- void complexDuplicateExpressionCheck(const std::list<const Function*> &constFunctions,
- const Token *classStart,
- const std::string &toCheck,
- const std::string &alt);
};
/// @}
//---------------------------------------------------------------------------