Code cleanup
This commit is contained in:
Daniel Marjamäki
parent
5ba02d2fdd
commit
83066edec0
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
};
|
||||
/// @}
|
||||
//---------------------------------------------------------------------------
|
||||
|
|
|
|||
Loading…
Reference in New Issue