Shorten code by using temp variables, cleanup variable names.

Dmitry-Me · Dmitry-Me · commit 13234a7366a7 · 2014-07-14T12:20:00.000+04:00
diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
@@ -1243,11 +1243,11 @@ void CheckBufferOverrun::checkStructVariable()
                         }
 
                         // Goto end of statement.
-                        const Token *CheckTok = nullptr;
+                        const Token *checkTok = nullptr;
                         while (tok3 && tok3 != func_scope->classEnd) {
                             // End of statement.
                             if (tok3->str() == ";") {
-                                CheckTok = tok3;
+                                checkTok = tok3;
                                 break;
                             }
 
@@ -1257,7 +1257,7 @@ void CheckBufferOverrun::checkStructVariable()
 
                             // Function implementation..
                             if (Token::simpleMatch(tok3, ") {")) {
-                                CheckTok = tok3->tokAt(2);
+                                checkTok = tok3->tokAt(2);
                                 break;
                             }
 
@@ -1267,7 +1267,7 @@ void CheckBufferOverrun::checkStructVariable()
                         if (!tok3)
                             break;
 
-                        if (!CheckTok)
+                        if (!checkTok)
                             continue;
 
                         // Check variable usage..
@@ -1278,7 +1278,7 @@ void CheckBufferOverrun::checkStructVariable()
                             varnames += (k == 0 ? "" : ".") + varname[k];
 
                         temp.varname(varnames);
-                        checkScope(CheckTok, varname, temp);
+                        checkScope(checkTok, varname, temp);
                     }
                 }
             }
diff --git a/lib/checkexceptionsafety.cpp b/lib/checkexceptionsafety.cpp
@@ -38,10 +38,10 @@ void CheckExceptionSafety::destructors()
     const std::size_t functions = symbolDatabase->functionScopes.size();
     for (std::size_t i = 0; i < functions; ++i) {
         const Scope * scope = symbolDatabase->functionScopes[i];
-        const Function * j = scope->function;
-        if (j) {
+        const Function * function = scope->function;
+        if (function) {
             // only looking for destructors
-            if (j->type == Function::eDestructor) {
+            if (function->type == Function::eDestructor) {
                 // Inspect this destructor.
                 for (const Token *tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {
                     // Skip try blocks
@@ -103,7 +103,7 @@ void CheckExceptionSafety::deallocThrow()
             const unsigned int varid(tok->varId());
 
             // Token where throw occurs
-            const Token *ThrowToken = nullptr;
+            const Token *throwToken = nullptr;
 
             // is there a throw after the deallocation?
             const Token* const end2 = tok->scope()->classEnd;
@@ -114,13 +114,13 @@ void CheckExceptionSafety::deallocThrow()
                         deallocThrowError(tok2, tok->str());
                         break;
                     }
-                    ThrowToken = tok2;
+                    throwToken = tok2;
                 }
 
                 // Variable is assigned -> Bail out
                 else if (Token::Match(tok2, "%varid% =", varid)) {
-                    if (ThrowToken) // For non-inconclusive checking, wait until we find an assignment to it. Otherwise we assume it is safe to leave a dead pointer.
-                        deallocThrowError(ThrowToken, tok2->str());
+                    if (throwToken) // For non-inconclusive checking, wait until we find an assignment to it. Otherwise we assume it is safe to leave a dead pointer.
+                        deallocThrowError(throwToken, tok2->str());
                     break;
                 }
                 // Variable passed to function. Assume it becomes assigned -> Bail out
@@ -236,32 +236,35 @@ void CheckExceptionSafety::nothrowThrows()
     const std::size_t functions = symbolDatabase->functionScopes.size();
     for (std::size_t i = 0; i < functions; ++i) {
         const Scope * scope = symbolDatabase->functionScopes[i];
+        const Function* function = scope->function;
+        if (!function)
+            continue;
 
         // check noexcept functions
-        if (scope->function && scope->function->isNoExcept &&
-            (!scope->function->noexceptArg || scope->function->noexceptArg->str() == "true")) {
-            const Token *throws = functionThrows(scope->function);
+        if (function->isNoExcept &&
+            (!function->noexceptArg || function->noexceptArg->str() == "true")) {
+            const Token *throws = functionThrows(function);
             if (throws)
                 noexceptThrowError(throws);
         }
 
         // check throw() functions
-        else if (scope->function && scope->function->isThrow && !scope->function->throwArg) {
-            const Token *throws = functionThrows(scope->function);
+        else if (function->isThrow && !function->throwArg) {
+            const Token *throws = functionThrows(function);
             if (throws)
                 nothrowThrowError(throws);
         }
 
         // check __attribute__((nothrow)) functions
-        else if (scope->function && scope->function->isAttributeNothrow()) {
-            const Token *throws = functionThrows(scope->function);
+        else if (function->isAttributeNothrow()) {
+            const Token *throws = functionThrows(function);
             if (throws)
                 nothrowAttributeThrowError(throws);
         }
 
         // check __declspec(nothrow) functions
-        else if (scope->function && scope->function->isDeclspecNothrow()) {
-            const Token *throws = functionThrows(scope->function);
+        else if (function->isDeclspecNothrow()) {
+            const Token *throws = functionThrows(function);
             if (throws)
                 nothrowDeclspecThrowError(throws);
         }

Original file line number	Diff line number	Diff line change
`@@ -1243,11 +1243,11 @@ void CheckBufferOverrun::checkStructVariable()`
`1243`	`1243`	`}`
`1244`	`1244`
`1245`	`1245`	`// Goto end of statement.`
`1246`		`- const Token *CheckTok = nullptr;`
	`1246`	`+ const Token *checkTok = nullptr;`
`1247`	`1247`	`while (tok3 && tok3 != func_scope->classEnd) {`
`1248`	`1248`	`// End of statement.`
`1249`	`1249`	`if (tok3->str() == ";") {`
`1250`		`- CheckTok = tok3;`
	`1250`	`+ checkTok = tok3;`
`1251`	`1251`	`break;`
`1252`	`1252`	`}`
`1253`	`1253`
`@@ -1257,7 +1257,7 @@ void CheckBufferOverrun::checkStructVariable()`
`1257`	`1257`
`1258`	`1258`	`// Function implementation..`
`1259`	`1259`	`if (Token::simpleMatch(tok3, ") {")) {`
`1260`		`- CheckTok = tok3->tokAt(2);`
	`1260`	`+ checkTok = tok3->tokAt(2);`
`1261`	`1261`	`break;`
`1262`	`1262`	`}`
`1263`	`1263`
`@@ -1267,7 +1267,7 @@ void CheckBufferOverrun::checkStructVariable()`
`1267`	`1267`	`if (!tok3)`
`1268`	`1268`	`break;`
`1269`	`1269`
`1270`		`- if (!CheckTok)`
	`1270`	`+ if (!checkTok)`
`1271`	`1271`	`continue;`
`1272`	`1272`
`1273`	`1273`	`// Check variable usage..`
`@@ -1278,7 +1278,7 @@ void CheckBufferOverrun::checkStructVariable()`
`1278`	`1278`	`varnames += (k == 0 ? "" : ".") + varname[k];`
`1279`	`1279`
`1280`	`1280`	`temp.varname(varnames);`
`1281`		`- checkScope(CheckTok, varname, temp);`
	`1281`	`+ checkScope(checkTok, varname, temp);`
`1282`	`1282`	`}`
`1283`	`1283`	`}`
`1284`	`1284`	`}`