Refactoring: Use std::string instead of const char *

lib/checkbufferoverrun.cpp

@@ -141,21 +141,13 @@ void CheckBufferOverrun::terminateStrncpyError(const Token *tok)
 // Check array usage..
 //---------------------------------------------------------------------------
 
-void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], const int size, const int total_size, unsigned int varid)
+void CheckBufferOverrun::checkScope(const Token *tok, const std::vector<std::string> &varname, const int size, const int total_size, unsigned int varid)
 {
-    unsigned int varc = 0;
-
     std::string varnames;
-    while (varname && varname[varc])
+    for (unsigned int i = 0; i < varname.size(); ++i)
-    {
+        varnames += (i==0?"":" . ") + varname[i];
-        if (varc > 0)
-            varnames += " . ";
-
-        varnames += varname[varc];
-
-        ++varc;
-    }
 
+    unsigned int varc = varname.size();
     if (varc == 0)
         varc = 1;
 
@@ -172,7 +164,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
     {
         if (Token::Match(tok, "%varid% [ %num% ]", varid))
         {
-            int index = std::strtol(tok->strAt(2), NULL, 10);
+            int index = MathLib::toLongNumber(tok->strAt(2));
             if (index < 0 || index >= size)
             {
                 arrayIndexOutOfBounds(tok, size, index);
@@ -181,7 +173,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
     }
     else if (Token::Match(tok, std::string(varnames + " [ %num% ]").c_str()))
     {
-        int index = std::strtol(tok->strAt(2 + varc), NULL, 10);
+        int index = MathLib::toLongNumber(tok->strAt(2 + varc));
         if (index < 0 || index >= size)
         {
             arrayIndexOutOfBounds(tok->tokAt(varc), size, index);
@@ -214,7 +206,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
         {
             if (!tok->isName() && !Token::Match(tok, "[.&]") && Token::Match(tok->next(), "%varid% [ %num% ]", varid))
             {
-                int index = std::strtol(tok->strAt(3), NULL, 10);
+                int index = MathLib::toLongNumber(tok->strAt(3));
                 if (index < 0 || index >= size)
                 {
                     if (index > size || !Token::Match(tok->previous(), "& ("))
@@ -226,7 +218,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
         }
         else if (!tok->isName() && !Token::Match(tok, "[.&]") && Token::Match(tok->next(), std::string(varnames + " [ %num% ]").c_str()))
         {
-            int index = std::strtol(tok->strAt(3 + varc), NULL, 10);
+            int index = MathLib::toLongNumber(tok->strAt(3 + varc));
             if (index < 0 || index >= size)
             {
                 arrayIndexOutOfBounds(tok->tokAt(1 + varc), size, index);
@@ -248,8 +240,8 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                     if (tokSz->isNumber())
                     {
                         // strncpy takes entire variable length as input size
-                        const char *num  = tok->strAt(6);
+                        const std::string num = tok->strAt(6);
-                        if (std::atoi(num) == total_size)
+                        if (MathLib::toLongNumber(num) == total_size)
                         {
                             const Token *tok2 = tok->next()->link()->next()->next();
                             for (; tok2; tok2 = tok2->next())
@@ -278,8 +270,8 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                     sizeArgumentAsChar(tok);
                 else if (tokSz->isNumber())
                 {
-                    const char *num  = tok->strAt(6);
+                    const std::string num = tok->strAt(6);
-                    if (std::atoi(num) < 0 || std::atoi(num) > total_size)
+                    if (MathLib::toLongNumber(num) < 0 || MathLib::toLongNumber(num) > total_size)
                     {
                         bufferOverrun(tok);
                     }
@@ -291,8 +283,8 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
             if (Token::Match(tok->next(), std::string("( " + varnames + " , %num% , %num% )").c_str()) ||
                 Token::Match(tok->next(), std::string("( %var% , " + varnames + " , %num% )").c_str()))
             {
-                const char *num  = tok->strAt(varc + 6);
+                const std::string num  = tok->strAt(varc + 6);
-                if (std::atoi(num) < 0 || std::atoi(num) > total_size)
+                if (MathLib::toLongNumber(num) < 0 || MathLib::toLongNumber(num) > total_size)
                 {
                     bufferOverrun(tok);
                 }
@@ -350,12 +342,12 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
 
             if (Token::Match(tok2, "%varid% < %num% ;", counter_varid))
             {
-                value = std::atoi(tok2->strAt(2));
+                value = MathLib::toLongNumber(tok2->strAt(2));
                 max_counter_value = MathLib::toString<long>(value - 1);
             }
             else if (Token::Match(tok2, "%varid% <= %num% ;", counter_varid))
             {
-                value = std::atoi(tok2->strAt(2)) + 1;
+                value = MathLib::toLongNumber(tok2->strAt(2)) + 1;
                 max_counter_value = tok2->strAt(2);
             }
 
@@ -373,7 +365,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                 if (!MathLib::isInt(tok3->strAt(2)))
                     continue;
 
-                const int num = std::atoi(tok3->strAt(2));
+                const int num = MathLib::toLongNumber(tok3->strAt(2));
 
                 // We have for example code: "for(i=2;i<22;i+=6)
                 // We can calculate that max value for i is 20, not 21
@@ -392,7 +384,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                 if (!MathLib::isInt(tok3->strAt(4)))
                     continue;
 
-                const int num = std::atoi(tok3->strAt(4));
+                const int num = MathLib::toLongNumber(tok3->strAt(4));
                 long max = MathLib::toLongNumber(max_counter_value);
                 long min = MathLib::toLongNumber(min_counter_value);
                 max = ((max - min) / num) * num + min;
@@ -474,7 +466,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                     if (Token::Match(tok2, "%varid% [ %var% +|-|*|/ %num% ]", varid) &&
                         tok2->tokAt(2)->varId() == counter_varid)
                     {
-                        char action = *(tok2->strAt(3));
+                        const char action = tok2->strAt(3)[0];
                         const std::string &second(tok2->tokAt(4)->str());
 
                         //printf("min_index: %s %c %s\n", min_counter_value.c_str(), action, second.c_str());
@@ -486,7 +478,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                     else if (Token::Match(tok2, "%varid% [ %num% +|-|*|/ %var% ]", varid) &&
                              tok2->tokAt(4)->varId() == counter_varid)
                     {
-                        char action = *(tok2->strAt(3));
+                        const char action = tok2->strAt(3)[0];
                         const std::string &first(tok2->tokAt(2)->str());
 
                         //printf("min_index: %s %c %s\n", first.c_str(), action, min_counter_value.c_str());
@@ -549,7 +541,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
         // Dangerous usage of strncat..
         if (varid > 0 && Token::Match(tok, "strncat ( %varid% , %any% , %num% )", varid))
         {
-            int n = std::atoi(tok->strAt(6));
+            int n = MathLib::toLongNumber(tok->strAt(6));
             if (n >= total_size)
                 strncatUsage(tok);
         }
@@ -558,7 +550,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
         // Dangerous usage of strncpy + strncat..
         if (varid > 0 && Token::Match(tok, "strncpy|strncat ( %varid% , %any% , %num% ) ; strncat ( %varid% , %any% , %num% )", varid))
         {
-            int n = std::atoi(tok->strAt(6)) + std::atoi(tok->strAt(15));
+            int n = MathLib::toLongNumber(tok->strAt(6)) + MathLib::toLongNumber(tok->strAt(15));
             if (n > total_size)
                 strncatUsage(tok->tokAt(9));
         }
@@ -590,7 +582,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
         // snprintf..
         if (varid > 0 && Token::Match(tok, "snprintf ( %varid% , %num% ,", varid))
         {
-            int n = std::atoi(tok->strAt(4));
+            int n = MathLib::toLongNumber(tok->strAt(4));
             if (n > total_size)
                 outOfBounds(tok->tokAt(4), "snprintf size");
         }
@@ -676,9 +668,10 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
                 else if (par == 1 && parlevel == 1 && Token::Match(ftok, "%var% [,)]"))
                 {
                     // Parameter name..
-                    const char *parname[2];
+                    std::vector<std::string> parname;
-                    parname[0] = ftok->str().c_str();
+                    parname.push_back(ftok->str());
-                    parname[1] = 0;
+
+                    const unsigned int parId = ftok->varId();
 
                     // Goto function body..
                     while (ftok && (ftok->str() != "{"))
@@ -691,7 +684,7 @@ void CheckBufferOverrun::checkScope(const Token *tok, const char *varname[], con
 
                     // Check variable usage in the function..
                     _callStack.push_back(tok1);
-                    checkScope(ftok, parname, size, total_size, 0);
+                    checkScope(ftok, parname, size, total_size, parId);
                     _callStack.pop_back();
 
                     // break out..
@@ -721,7 +714,7 @@ void CheckBufferOverrun::checkGlobalAndLocalVariable()
             --indentlevel;
 
         unsigned int size = 0;
-        const char *type = 0;
+        std::string type;
         unsigned int varid = 0;
         int nextTok = 0;
 
@@ -734,14 +727,14 @@ void CheckBufferOverrun::checkGlobalAndLocalVariable()
             unsigned int varpos = 1;
             if (tok->next()->str() == "*")
                 ++varpos;
-            size = std::strtoul(tok->strAt(varpos + 2), NULL, 10);
+            size = MathLib::toLongNumber(tok->strAt(varpos + 2));
             type = tok->strAt(varpos - 1);
             varid = tok->tokAt(varpos)->varId();
             nextTok = varpos + 5;
         }
         else if (indentlevel > 0 && Token::Match(tok, "[*;{}] %var% = new %type% [ %num% ]"))
         {
-            size = std::strtoul(tok->strAt(6), NULL, 10);
+            size = MathLib::toLongNumber(tok->strAt(6));
             type = tok->strAt(4);
             varid = tok->tokAt(1)->varId();
             nextTok = 8;
@@ -755,7 +748,7 @@ void CheckBufferOverrun::checkGlobalAndLocalVariable()
         }
         else if (indentlevel > 0 && Token::Match(tok, "[*;{}] %var% = malloc ( %num% ) ;"))
         {
-            size = std::strtoul(tok->strAt(5), NULL, 10);
+            size = MathLib::toLongNumber(tok->strAt(5));
             type = "char";
             varid = tok->tokAt(1)->varId();
             nextTok = 7;
@@ -789,7 +782,8 @@ void CheckBufferOverrun::checkGlobalAndLocalVariable()
 
         // The callstack is empty
         _callStack.clear();
-        checkScope(tok->tokAt(nextTok), 0, size, total_size, varid);
+        std::vector<std::string> v;
+        checkScope(tok->tokAt(nextTok), v, size, total_size, varid);
     }
 }
 //---------------------------------------------------------------------------
@@ -825,10 +819,10 @@ void CheckBufferOverrun::checkStructVariable()
             else
                 continue;
 
-            const char *varname[3] = {0, 0, 0};
+            std::vector<std::string> varname(2, "");
             const unsigned int varId = tok2->tokAt(ivar)->varId();
             varname[1] = tok2->strAt(ivar);
-            int arrsize = std::atoi(tok2->strAt(ivar + 2));
+            int arrsize = MathLib::toLongNumber(tok2->strAt(ivar + 2));
             int total_size = arrsize * _tokenizer->sizeOfType(tok2->tokAt(1));
             if (tok2->tokAt(2)->str() == "*")
                 total_size = arrsize * _tokenizer->sizeOfType(tok2->tokAt(2));
@@ -850,7 +844,8 @@ void CheckBufferOverrun::checkStructVariable()
 
                         if (Token::simpleMatch(tok4, ") {"))
                         {
-                            checkScope(tok4->tokAt(2), 0, arrsize, total_size, varId);
+                            std::vector<std::string> v;
+                            checkScope(tok4->tokAt(2), v, arrsize, total_size, varId);
                             break;
                         }
                     }

lib/checkbufferoverrun.h

@@ -25,6 +25,8 @@
 #include "check.h"
 #include "settings.h"
 #include <list>
+#include <vector>
+#include <string>
 
 class ErrorLogger;
 class Token;
@@ -74,7 +76,7 @@ private:
     void checkGlobalAndLocalVariable();
 
     /** Check for buffer overruns - this is the function that performs the actual checking */
-    void checkScope(const Token *tok, const char *varname[], const int size, const int total_size, unsigned int varid);
+    void checkScope(const Token *tok, const std::vector<std::string> &varname, const int size, const int total_size, unsigned int varid);
 
     /** callstack - used during intra-function checking */
     std::list<const Token *> _callStack;

lib/checkclass.cpp

@@ -87,7 +87,7 @@ CheckClass::Var *CheckClass::getVarList(const Token *tok1, bool withClasses, boo
         }
 
         // "private:" "public:" "protected:" etc
-        const bool b((*tok->strAt(0) != ':') && strchr(tok->strAt(0), ':') != 0);
+        const bool b((tok->str()[0] != ':') && tok->str().find(":") != std::string::npos);
 
         if (b)
             priv = bool(tok->str() == "private:");
@@ -98,7 +98,7 @@ CheckClass::Var *CheckClass::getVarList(const Token *tok1, bool withClasses, boo
 
         // This is the start of a statement
         const Token *next = tok->next();
-        const char *varname = 0;
+        std::string varname;
 
         // If next token contains a ":".. it is not part of a variable declaration
         if (next->str().find(":") != std::string::npos)
@@ -165,7 +165,7 @@ CheckClass::Var *CheckClass::getVarList(const Token *tok1, bool withClasses, boo
         }
 
         // If the varname was set in one of the two if-block above, create a entry for this variable..
-        if (varname && strcmp(varname, "operator"))
+        if (!varname.empty() && varname != "operator")
         {
             Var *var = new Var(varname, false, priv, varlist);
             varlist  = var;
@@ -176,11 +176,11 @@ CheckClass::Var *CheckClass::getVarList(const Token *tok1, bool withClasses, boo
 }
 //---------------------------------------------------------------------------
 
-void CheckClass::initVar(Var *varlist, const char varname[])
+void CheckClass::initVar(Var *varlist, const std::string &varname)
 {
     for (Var *var = varlist; var; var = var->next)
     {
-        if (strcmp(var->name, varname) == 0)
+        if (var->name == varname)
         {
             var->init = true;
             return;
@@ -189,7 +189,7 @@ void CheckClass::initVar(Var *varlist, const char varname[])
 }
 //---------------------------------------------------------------------------
 
-void CheckClass::initializeVarList(const Token *tok1, const Token *ftok, Var *varlist, const char classname[], std::list<std::string> &callstack, bool isStruct)
+void CheckClass::initializeVarList(const Token *tok1, const Token *ftok, Var *varlist, const std::string &classname, std::list<std::string> &callstack, bool isStruct)
 {
     bool Assign = false;
     unsigned int indentlevel = 0;
@@ -401,8 +401,7 @@ void CheckClass::constructors()
     const Token *tok1 = Token::findmatch(_tokenizer->tokens(), pattern_class);
     while (tok1)
     {
-        const char *className;
+        const std::string className = tok1->strAt(1);
-        className = tok1->strAt(1);
         const Token *classNameToken = tok1->tokAt(1);
         bool isStruct = tok1->str() == "struct";
 
@@ -499,12 +498,12 @@ void CheckClass::constructors()
     }
 }
 
-void CheckClass::checkConstructors(const Token *tok1, const char funcname[], bool hasPrivateConstructor, bool isStruct)
+void CheckClass::checkConstructors(const Token *tok1, const std::string &funcname, bool hasPrivateConstructor, bool isStruct)
 {
-    const char * const className = tok1->strAt(1);
+    const std::string className = tok1->strAt(1);
 
     // Check that all member variables are initialized..
-    bool withClasses = bool(_settings->_showAll && std::string(funcname) == "operator =");
+    bool withClasses = bool(_settings->_showAll && funcname == "operator =");
     Var *varlist = getVarList(tok1, withClasses, isStruct);
 
     int indentlevel = 0;
@@ -737,7 +736,7 @@ void CheckClass::noMemset()
         if (!Token::Match(tok, "memset|memcpy|memmove"))
             continue;
 
-        const char *type = NULL;
+        std::string type;
         if (Token::Match(tok, "memset ( %var% , %num% , sizeof ( %type% ) )"))
             type = tok->strAt(8);
         else if (Token::Match(tok, "memset ( & %var% , %num% , sizeof ( %type% ) )"))
@@ -750,7 +749,7 @@ void CheckClass::noMemset()
             type = tok->strAt(8);
 
         // No type defined => The tokens didn't match
-        if (!(type && type[0]))
+        if (type.empty())
             continue;
 
         // Warn if type is a class or struct that contains any std::* variables
@@ -1319,9 +1318,7 @@ void CheckClass::virtualDestructor()
                 derived = derived->next();
 
             // Name of base class..
-            const char *baseName[2];
+            const std::string baseName = derived->strAt(0);
-            baseName[0] = derived->strAt(0);
-            baseName[1] = 0;
 
             // Update derived so it's ready for the next loop.
             do
@@ -1344,9 +1341,9 @@ void CheckClass::virtualDestructor()
                 continue;
 
             // Find the destructor declaration for the base class.
-            const Token *base = Token::findmatch(_tokenizer->tokens(), (std::string("%any% ~ ") + baseName[0] + " (").c_str());
+            const Token *base = Token::findmatch(_tokenizer->tokens(), (std::string("%any% ~ ") + baseName + " (").c_str());
             while (base && base->str() == "::")
-                base = Token::findmatch(base->next(), (std::string("%any% ~ ") + baseName[0] + " (").c_str());
+                base = Token::findmatch(base->next(), (std::string("%any% ~ ") + baseName + " (").c_str());
 
             const Token *reverseTok = base;
             while (Token::Match(base, "%var%") && base->str() != "virtual")
@@ -1356,10 +1353,10 @@ void CheckClass::virtualDestructor()
             if (! base)
             {
                 // Is the class declaration available?
-                base = Token::findmatch(_tokenizer->tokens(), (std::string("class ") + baseName[0] + " {").c_str());
+                base = Token::findmatch(_tokenizer->tokens(), (std::string("class ") + baseName + " {").c_str());
                 if (base)
                 {
-                    virtualDestructorError(base, baseName[0], derivedClass->str());
+                    virtualDestructorError(base, baseName, derivedClass->str());
                 }
 
                 continue;
@@ -1375,7 +1372,7 @@ void CheckClass::virtualDestructor()
             // Proper solution is to check all of the base classes. If base class is not
             // found or if one of the base classes has virtual destructor, error should not
             // be printed. See TODO test case "virtualDestructorInherited"
-            if (!Token::findmatch(_tokenizer->tokens(), (std::string("class ") + baseName[0] + " {").c_str()))
+            if (!Token::findmatch(_tokenizer->tokens(), (std::string("class ") + baseName + " {").c_str()))
                 continue;
 
             // Make sure that the destructor is public (protected or private
@@ -1386,7 +1383,7 @@ void CheckClass::virtualDestructor()
             {
                 if (reverseTok->str() == "public:")
                 {
-                    virtualDestructorError(base, baseName[0], derivedClass->str());
+                    virtualDestructorError(base, baseName, derivedClass->str());
                     break;
                 }
                 else if (reverseTok->str() == "protected:" ||

lib/checkclass.h

@@ -106,16 +106,16 @@ private:
     class Var
     {
     public:
-        Var(const char *name = 0, bool init = false, bool priv = false, Var *next = 0)
+        Var(const std::string &name_, bool init = false, bool priv = false, Var *next = 0)
+            : name(name_)
         {
-            this->name = name;
             this->init = init;
             this->priv = priv;
             this->next = next;
         }
 
         /** @brief name of variable */
-        const char *name;
+        const std::string name;
 
         /** @brief has this variable been initialized? */
         bool        init;
@@ -136,10 +136,10 @@ private:
      * @param callstack the function doesn't look into recursive function calls.
      * @param isStruct if this is a struct instead of a class
      */
-    void initializeVarList(const Token *tok1, const Token *ftok, Var *varlist, const char classname[], std::list<std::string> &callstack, bool isStruct);
+    void initializeVarList(const Token *tok1, const Token *ftok, Var *varlist, const std::string &classname, std::list<std::string> &callstack, bool isStruct);
 
     /** @brief initialize a variable in the varlist */
-    void initVar(Var *varlist, const char varname[]);
+    void initVar(Var *varlist, const std::string &varname);
 
     /**
      * @brief get varlist from a class definition
@@ -150,7 +150,7 @@ private:
     Var *getVarList(const Token *tok1, bool withClasses, bool isStruct);
 
     // Check constructors for a specified class
-    void checkConstructors(const Token *tok1, const char funcname[], bool hasPrivateConstructor, bool isStruct);
+    void checkConstructors(const Token *tok1, const std::string &funcname, bool hasPrivateConstructor, bool isStruct);
 
     // Reporting errors..
     void noConstructorError(const Token *tok, const std::string &classname, bool isStruct);

lib/checkheaders.cpp

@@ -97,10 +97,10 @@ void CheckHeaders::warningIncludeHeader()
 
         // Get fileindex of included file..
         unsigned int hfile = 0;
-        const char *includefile = includetok->strAt(1);
+        const std::string includefile = includetok->strAt(1);
         while (hfile < _tokenizer->getFiles()->size())
         {
-            if (FileLister::sameFileName(_tokenizer->getFiles()->at(hfile).c_str(), includefile))
+            if (FileLister::sameFileName(_tokenizer->getFiles()->at(hfile), includefile))
                 break;
             ++hfile;
         }
@@ -184,7 +184,7 @@ void CheckHeaders::warningIncludeHeader()
             // --------------------------------------
             else if (tok1->str() == "typedef")
             {
-                if (strcmp(tok1->strAt(1), "enum") == 0)
+                if (tok1->strAt(1) == "enum")
                     continue;
                 int parlevel = 0;
                 while (tok1->next())
@@ -220,7 +220,7 @@ void CheckHeaders::warningIncludeHeader()
 
             if (Token::Match(tok1, ": %var% {") || Token::Match(tok1, ": %type% %var% {"))
             {
-                std::string classname = tok1->strAt((strcmp(tok1->strAt(2), "{")) ? 2 : 1);
+                const std::string classname = tok1->strAt(((tok1->strAt(2) != "{")) ? 2 : 1);
                 if (std::find(classlist.begin(), classlist.end(), classname) != classlist.end())
                 {
                     Needed = true;

lib/checkmemoryleak.cpp

@@ -527,16 +527,16 @@ static int countParameters(const Token *tok)
     return -1;
 }
 
-bool CheckMemoryLeakInFunction::test_white_list(const char funcname[])
+bool CheckMemoryLeakInFunction::test_white_list(const std::string &funcname)
 {
-    return std::bsearch(funcname, call_func_white_list,
+    return std::bsearch(funcname.c_str(), call_func_white_list,
                         sizeof(call_func_white_list) / sizeof(call_func_white_list[0]),
                         sizeof(call_func_white_list[0]), call_func_white_list_compare);
 }
 
 const char * CheckMemoryLeakInFunction::call_func(const Token *tok, std::list<const Token *> callstack, const unsigned int varid, AllocType &alloctype, AllocType &dealloctype, bool &all, unsigned int sz)
 {
-    if (test_white_list(tok->strAt(0)))
+    if (test_white_list(tok->str()))
         return 0;
 
     if (noreturn.find(tok->str()) != noreturn.end())
@@ -2408,7 +2408,7 @@ void CheckMemoryLeakInClass::variable(const std::string &classname, const Token
                 // Function call in destructor .. possible deallocation
                 else if (destructor && Token::Match(tok->previous(), "[{};] %var% ("))
                 {
-                    if (!std::bsearch(tok->strAt(0), call_func_white_list,
+                    if (!std::bsearch(tok->str().c_str(), call_func_white_list,
                                       sizeof(call_func_white_list) / sizeof(call_func_white_list[0]),
                                       sizeof(call_func_white_list[0]), call_func_white_list_compare))
                     {

lib/checkmemoryleak.h

@@ -160,7 +160,7 @@ public:
     }
 
     /** For unit testing the white list */
-    static bool test_white_list(const char funcname[]);
+    static bool test_white_list(const std::string &funcname);
 
     void check();
 

lib/checkother.cpp

@@ -315,8 +315,8 @@ void CheckOther::checkUnsignedDivision()
     {
         if (Token::Match(tok, "[{};(,] %type% %var% [;=,)]"))
         {
-            const char *type = tok->strAt(1);
+            const std::string type = tok->strAt(1);
-            if (strcmp(type, "char") == 0 || strcmp(type, "short") == 0 || strcmp(type, "int") == 0)
+            if (type == "char" || type == "short" || type == "int")
                 varsign[tok->tokAt(2)->varId()] = 's';
         }
 
@@ -451,7 +451,7 @@ void CheckOther::checkVariableScope()
 }
 //---------------------------------------------------------------------------
 
-void CheckOther::lookupVar(const Token *tok1, const char varname[])
+void CheckOther::lookupVar(const Token *tok1, const std::string &varname)
 {
     const Token *tok = tok1;
 
@@ -607,7 +607,7 @@ void CheckOther::checkConstantFunctionParameter()
 
 void CheckOther::checkStructMemberUsage()
 {
-    const char *structname = 0;
+    std::string structname;
     for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next())
     {
         if (tok->fileIndex() != 0)
@@ -622,7 +622,7 @@ void CheckOther::checkStructMemberUsage()
             {
                 if (tok2->str() == "(")
                 {
-                    structname = 0;
+                    structname = "";
                     break;
                 }
 
@@ -633,15 +633,15 @@ void CheckOther::checkStructMemberUsage()
             // Bail out if some data is casted to struct..
             const std::string s("( struct| " + tok->next()->str() + " * ) & %var% [");
             if (Token::findmatch(tok, s.c_str()))
-                structname = 0;
+                structname = "";
         }
 
         if (tok->str() == "}")
-            structname = 0;
+            structname = "";
 
-        if (structname && Token::Match(tok, "[{;]"))
+        if (!structname.empty() && Token::Match(tok, "[{;]"))
         {
-            const char *varname = 0;
+            std::string varname;
             if (Token::Match(tok->next(), "%type% %var% [;[]"))
                 varname = tok->strAt(2);
             else if (Token::Match(tok->next(), "%type% %type% %var% [;[]"))
@@ -653,7 +653,7 @@ void CheckOther::checkStructMemberUsage()
             else
                 continue;
 
-            const std::string usagePattern(". " + std::string(varname));
+            const std::string usagePattern(". " + varname);
             bool used = false;
             for (const Token *tok2 = _tokenizer->tokens(); tok2; tok2 = tok2->next())
             {
@@ -834,8 +834,8 @@ void CheckOther::strPlusChar()
         else if (Token::Match(tok, "[=(] %str% + %any%"))
         {
             // char constant..
-            const char *s = tok->strAt(3);
+            const std::string s = tok->strAt(3);
-            if (*s == '\'')
+            if (s[0] == '\'')
                 strPlusChar(tok->next());
 
             // char variable..

lib/checkother.h

@@ -128,7 +128,7 @@ public:
     /** Check for post increment/decrement in for loop*/
     void postIncrement();
 
-    void lookupVar(const Token *tok1, const char varname[]);
+    void lookupVar(const Token *tok1, const std::string &varname);
 
     // Redundant condition
     // if (haystack.find(needle) != haystack.end())

lib/checkunusedfunctions.cpp

@@ -73,7 +73,7 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer)
             funcname = tok->tokAt(1);
         else if (Token::Match(tok, "%type% * %var% ("))
             funcname = tok->tokAt(2);
-        else if (Token::Match(tok, "%type% :: %var% (") && !Token::Match(tok, tok->strAt(2)))
+        else if (Token::Match(tok, "%type% :: %var% (") && !Token::Match(tok, tok->strAt(2).c_str()))
             funcname = tok->tokAt(2);
 
         // Don't assume throw as a function name: void foo() throw () {}

lib/filelister.cpp

@@ -310,18 +310,18 @@ void FileLister::recursiveAddFiles(std::vector<std::string> &filenames, const st
 
 //---------------------------------------------------------------------------
 
-bool FileLister::sameFileName(const char fname1[], const char fname2[])
+bool FileLister::sameFileName(const std::string &fname1, const std::string &fname2)
 {
 #if defined(__linux__) || defined(__sun)
-    return bool(strcmp(fname1, fname2) == 0);
+    return bool(fname1 == fname2);
 #endif
 #ifdef __GNUC__
-    return bool(strcasecmp(fname1, fname2) == 0);
+    return bool(strcasecmp(fname1.c_str(), fname2.c_str()) == 0);
 #endif
 #ifdef __BORLANDC__
-    return bool(stricmp(fname1, fname2) == 0);
+    return bool(stricmp(fname1.c_str(), fname2.c_str()) == 0);
 #endif
 #ifdef _MSC_VER
-    return bool(_stricmp(fname1, fname2) == 0);
+    return bool(_stricmp(fname1.c_str(), fname2.c_str()) == 0);
 #endif
 }

lib/filelister.h

@@ -31,7 +31,7 @@ class FileLister
 public:
     static void recursiveAddFiles(std::vector<std::string> &filenames, const std::string &path, bool recursive);
     static std::string simplifyPath(const char *originalPath);
-    static bool sameFileName(const char fname1[], const char fname2[]);
+    static bool sameFileName(const std::string &fname1, const std::string &fname2);
     static bool acceptFile(const std::string &filename);
 private:
 

lib/settings.cpp

@@ -180,7 +180,7 @@ void Settings::addAutoAllocClass(const std::string &name)
     _autoDealloc.insert(name);
 }
 
-bool Settings::isAutoDealloc(const char classname[]) const
+bool Settings::isAutoDealloc(const std::string &classname) const
 {
     return (_autoDealloc.find(classname) != _autoDealloc.end());
 }

lib/settings.h

@@ -103,7 +103,7 @@ public:
     void addAutoAllocClass(const std::string &name);
 
     /** is a class automaticly deallocated? */
-    bool isAutoDealloc(const char classname[]) const;
+    bool isAutoDealloc(const std::string &classname) const;
 
     /** assign append code */
     void append(const std::string &filename);

lib/token.cpp

@@ -183,7 +183,7 @@ Token *Token::tokAt(int index)
     return tok;
 }
 
-const char *Token::strAt(int index) const
+std::string Token::strAt(int index) const
 {
     const Token *tok = this->tokAt(index);
     return tok ? tok->_str.c_str() : "";
@@ -592,7 +592,7 @@ const Token *Token::findmatch(const Token *tok, const char pattern[], unsigned i
     return 0;
 }
 
-void Token::insertToken(const char str[])
+void Token::insertToken(const std::string &str)
 {
     Token *newToken = new Token(tokensBack);
     newToken->str(str);

lib/token.h

@@ -69,7 +69,7 @@ public:
     const Token *tokAt(int index) const;
     Token *tokAt(int index);
 
-    const char *strAt(int index) const;
+    std::string strAt(int index) const;
 
     /**
      * Match given token (or list of tokens) to a pattern list.
@@ -202,7 +202,7 @@ public:
      * relations between next and previous token also.
      * @param str String for the new token.
      */
-    void insertToken(const char str[]);
+    void insertToken(const std::string &str);
 
     Token *previous() const
     {

lib/tokenize.cpp

@@ -125,7 +125,7 @@ void Tokenizer::addtoken(const char str[], const unsigned int lineno, const unsi
 
 unsigned int Tokenizer::sizeOfType(const Token *type) const
 {
-    if (!type || !type->strAt(0))
+    if (!type || type->str().empty())
         return 0;
 
     if (type->str()[0] == '"')
@@ -479,7 +479,7 @@ void Tokenizer::simplifyTypedef()
             tok = tok3;
         }
 
-        const char *typeName = 0;
+        std::string typeName;
         std::list<std::string> pointers;
         Token *typeStart = 0;
         Token *typeEnd = 0;
@@ -1733,7 +1733,7 @@ void Tokenizer::updateClassList()
         if (tok1->str() == "struct")
             memberType = ClassInfo::PUBLIC;
 
-        const char *className = tok1->strAt(1);
+        const std::string className = tok1->strAt(1);
         tok1 = tok1->next();
         int indentlevel = 0;
         for (const Token *tok = tok1; tok; tok = tok->next())
@@ -2703,7 +2703,7 @@ bool Tokenizer::simplifyTokenList()
                 continue;
             }
 
-            const char *num = tok->strAt(4);
+            const std::string num = tok->strAt(4);
             int indent = 1;
             for (Token *tok2 = tok->tokAt(6); tok2; tok2 = tok2->next())
             {
@@ -2746,15 +2746,21 @@ bool Tokenizer::simplifyTokenList()
 
         if (Token::Match(next, "* ( %var% + %num% )"))
         {
-            const char *str[4] = {"var", "[", "num", "]"};
+            // var
-            str[0] = tok->strAt(3);
-            str[2] = tok->strAt(5);
-
-            for (int i = 0; i < 4; i++)
-            {
             tok = tok->next();
-                tok->str(str[i]);
+            tok->str(tok->strAt(2));
-            }
+
+            // [
+            tok = tok->next();
+            tok->str("[");
+
+            // num
+            tok = tok->next();
+            tok->str(tok->strAt(2));
+
+            // ]
+            tok = tok->next();
+            tok->str("]");
 
             tok->deleteNext();
             tok->deleteNext();
@@ -3311,8 +3317,8 @@ bool Tokenizer::simplifyConditions()
             if (Token::Match(tok->tokAt(1), "%num%"))
             {
                 // Compare numbers
-                double op1 = (strstr(tok->strAt(1), "0x")) ? std::strtol(tok->strAt(1), 0, 16) : std::atof(tok->strAt(1));
+                double op1 = MathLib::toDoubleNumber(tok->strAt(1));
-                double op2 = (strstr(tok->strAt(3), "0x")) ? std::strtol(tok->strAt(3), 0, 16) : std::atof(tok->strAt(3));
+                double op2 = MathLib::toDoubleNumber(tok->strAt(3));
 
                 if (cmp == "==")
                     result = (op1 == op2);
@@ -4743,7 +4749,7 @@ bool Tokenizer::simplifyCalculations()
             else if (Token::Match(tok->previous(), "- %num% + %num%"))
                 tok->str(MathLib::calculate(tok->str(), tok->tokAt(2)->str(), '-'));
             else
-                tok->str(MathLib::calculate(tok->str(), tok->tokAt(2)->str(), *(tok->strAt(1))));
+                tok->str(MathLib::calculate(tok->str(), tok->tokAt(2)->str(), tok->strAt(1)[0]));
 
             Token::eraseTokens(tok, tok->tokAt(3));
 
@@ -5130,14 +5136,14 @@ void Tokenizer::simplifyEnum()
                     }
                     else
                     {
-                        tok1->insertToken(MathLib::toString<long>(lastValue).c_str());
+                        tok1->insertToken(MathLib::toString<long>(lastValue));
                         enumValue = tok1->next();
                     }
                 }
                 else if (Token::Match(tok1->previous(), ",|{ %type% = %num% ,|}"))
                 {
                     enumName = tok1;
-                    lastValue = std::atoi(tok1->strAt(2));
+                    lastValue = MathLib::toLongNumber(tok1->strAt(2));
                     enumValue = tok1->tokAt(2);
                     lastEnumValueStart = 0;
                     lastEnumValueEnd = 0;
@@ -5506,7 +5512,7 @@ std::string Tokenizer::file(const Token *tok) const
 
 //---------------------------------------------------------------------------
 
-const Token * Tokenizer::findClassFunction(const Token *tok, const char classname[], const char funcname[], int &indentlevel, bool isStruct) const
+const Token * Tokenizer::findClassFunction(const Token *tok, const std::string &classname, const std::string &funcname, int &indentlevel, bool isStruct) const
 {
     if (indentlevel < 0 || tok == NULL)
         return NULL;

lib/tokenize.h

@@ -115,7 +115,7 @@ public:
      * @param isStruct is it a struct
      * @return First matching token or NULL.
      */
-    const Token *findClassFunction(const Token *tok, const char classname[], const char funcname[], int &indentlevel, bool isStruct = false) const;
+    const Token *findClassFunction(const Token *tok, const std::string &classname, const std::string &funcname, int &indentlevel, bool isStruct = false) const;
 
     /**
      * get error messages