/* * Cppcheck - A tool for static C/C++ code analysis * Copyright (C) 2007-2016 Cppcheck team. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "settings.h" #include "valueflow.h" bool Settings::_terminated; Settings::Settings() : _enabled(0), debug(false), debugnormal(false), debugwarnings(false), dump(false), exceptionHandling(false), inconclusive(false), jointSuppressionReport(false), experimental(false), quiet(false), inlineSuppressions(false), verbose(false), force(false), relativePaths(false), xml(false), xml_version(2), jobs(1), loadAverage(0), exitCode(0), showtime(SHOWTIME_NONE), preprocessOnly(false), maxConfigs(12), enforcedLang(None), reportProgress(false), checkConfiguration(false), checkLibrary(false) { } std::string Settings::addEnabled(const std::string &str) { // Enable parameters may be comma separated... if (str.find(',') != std::string::npos) { std::string::size_type prevPos = 0; std::string::size_type pos = 0; while ((pos = str.find(',', pos)) != std::string::npos) { if (pos == prevPos) return std::string("cppcheck: --enable parameter is empty"); const std::string errmsg(addEnabled(str.substr(prevPos, pos - prevPos))); if (!errmsg.empty()) return errmsg; ++pos; prevPos = pos; } if (prevPos >= str.length()) return std::string("cppcheck: --enable parameter is empty"); return addEnabled(str.substr(prevPos)); } if (str == "all") { _enabled |= WARNING | STYLE | PERFORMANCE | PORTABILITY | INFORMATION | UNUSED_FUNCTION | MISSING_INCLUDE; } else if (str == "warning") { _enabled |= WARNING; } else if (str == "style") { _enabled |= STYLE; } else if (str == "performance") { _enabled |= PERFORMANCE; } else if (str == "portability") { _enabled |= PORTABILITY; } else if (str == "information") { _enabled |= INFORMATION | MISSING_INCLUDE; } else if (str == "unusedFunction") { _enabled |= UNUSED_FUNCTION; } else if (str == "missingInclude") { _enabled |= MISSING_INCLUDE; } #ifdef CHECK_INTERNAL else if (str == "internal") { _enabled |= INTERNAL; } #endif else { if (str.empty()) return std::string("cppcheck: --enable parameter is empty"); else return std::string("cppcheck: there is no --enable parameter with the name '" + str + "'"); } return std::string(); } bool Settings::isEnabled(Severity::SeverityType severity) const { switch (severity) { case Severity::none: return true; case Severity::error: return true; case Severity::warning: return isEnabled(WARNING); case Severity::style: return isEnabled(STYLE); case Severity::performance: return isEnabled(PERFORMANCE); case Severity::portability: return isEnabled(PORTABILITY); case Severity::information: return isEnabled(INFORMATION); case Severity::debug: return false; default: return false; } } bool Settings::isEnabled(const ValueFlow::Value *value, bool inconclusiveCheck) const { if (!isEnabled(Settings::WARNING) && (value->condition || value->defaultArg)) return false; if (!inconclusive && (inconclusiveCheck || value->isInconclusive())) return false; return true; }