astyle formatting

danmar · danmar · commit 484b68c550af · 2020-11-28T05:52:35.000+01:00
diff --git a/lib/checkunusedvar.cpp b/lib/checkunusedvar.cpp
@@ -1517,8 +1517,8 @@ bool CheckUnusedVar::isRecordTypeWithoutSideEffects(const Type* type)
                         return withoutSideEffects = false;
                     }
                     const Function* initValueFunc = valueToken->function();
-                    if (initValueFunc && !isFunctionWithoutSideEffects(*initValueFunc, valueToken, 
-                        std::list<const Function*>{})) {
+                    if (initValueFunc && !isFunctionWithoutSideEffects(*initValueFunc, valueToken,
+                    std::list<const Function*> {})) {
                         return withoutSideEffects = false;
                     }
                 }
@@ -1594,7 +1594,8 @@ bool CheckUnusedVar::isEmptyType(const Type* type)
 }
 
 bool CheckUnusedVar::isFunctionWithoutSideEffects(const Function& func, const Token* functionUsageToken,
-        std::list<const Function*> checkedFuncs) {
+        std::list<const Function*> checkedFuncs)
+{
     // no body to analyze
     if (!func.hasBody()) {
         return false;
@@ -1608,17 +1609,16 @@ bool CheckUnusedVar::isFunctionWithoutSideEffects(const Function& func, const To
     }
 
     bool sideEffectReturnFound = false;
-    for (Token* bodyToken = func.functionScope->bodyStart->next(); bodyToken != func.functionScope->bodyEnd; 
-        bodyToken = bodyToken->next())
-    {
+    for (Token* bodyToken = func.functionScope->bodyStart->next(); bodyToken != func.functionScope->bodyEnd;
+         bodyToken = bodyToken->next()) {
         const Variable* bodyVariable = bodyToken->variable();
         if (bodyVariable) {
             // check variable for side-effects
             if (!isVariableWithoutSideEffects(*bodyVariable)) {
                 return false;
             }
             // check if global variable is changed
-            if (bodyVariable->isGlobal()) { 
+            if (bodyVariable->isGlobal()) {
                 return false; // TODO: analyze global variable usage
             }
         }
@@ -1645,7 +1645,7 @@ bool CheckUnusedVar::isFunctionWithoutSideEffects(const Function& func, const To
             }
             // simple one-token return
             const Variable* returnVariable = returnValueToken->variable();
-            if (returnValueToken->isLiteral() || 
+            if (returnValueToken->isLiteral() ||
                 (returnVariable && isVariableWithoutSideEffects(*returnVariable))) {
                 continue;
             }
diff --git a/lib/checkunusedvar.h b/lib/checkunusedvar.h
@@ -75,7 +75,7 @@ class CPPCHECKLIB CheckUnusedVar : public Check {
     bool isVariableWithoutSideEffects(const Variable& var);
     bool isEmptyType(const Type* type);
     bool isFunctionWithoutSideEffects(const Function& func, const Token* functionUsageToken,
-        std::list<const Function*> checkedFuncs);
+                                      std::list<const Function*> checkedFuncs);
 
     // Error messages..
     void unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname, bool isUnion = false);
diff --git a/test/testunusedvar.cpp b/test/testunusedvar.cpp
@@ -515,8 +515,7 @@ class TestUnusedVar : public TestFixture {
         ASSERT_EQUALS("", errout.str());
     }
 
-    void cleanFunction()
-    {
+    void cleanFunction() {
         // unknown function
         functionVariableUsage(
             "class F {\n"
@@ -541,7 +540,7 @@ class TestUnusedVar : public TestFixture {
             "   C c;\n"
             "}");
         ASSERT_EQUALS("", errout.str());
-        
+
         // return literal
         functionVariableUsage(
             "int func() { return 1; }\n"

Original file line number	Diff line number	Diff line change
`@@ -1517,8 +1517,8 @@ bool CheckUnusedVar::isRecordTypeWithoutSideEffects(const Type* type)`
`1517`	`1517`	`return withoutSideEffects = false;`
`1518`	`1518`	`}`
`1519`	`1519`	`const Function* initValueFunc = valueToken->function();`
`1520`		`- if (initValueFunc && !isFunctionWithoutSideEffects(*initValueFunc, valueToken,`
`1521`		`- std::list<const Function*>{})) {`
	`1520`	`+ if (initValueFunc && !isFunctionWithoutSideEffects(*initValueFunc, valueToken,`
	`1521`	`+ std::list<const Function*> {})) {`
`1522`	`1522`	`return withoutSideEffects = false;`
`1523`	`1523`	`}`
`1524`	`1524`	`}`
`@@ -1594,7 +1594,8 @@ bool CheckUnusedVar::isEmptyType(const Type* type)`
`1594`	`1594`	`}`
`1595`	`1595`
`1596`	`1596`	`bool CheckUnusedVar::isFunctionWithoutSideEffects(const Function& func, const Token* functionUsageToken,`
`1597`		`- std::list<const Function*> checkedFuncs) {`
	`1597`	`+ std::list<const Function*> checkedFuncs)`
	`1598`	`+{`
`1598`	`1599`	`// no body to analyze`
`1599`	`1600`	`if (!func.hasBody()) {`
`1600`	`1601`	`return false;`
`@@ -1608,17 +1609,16 @@ bool CheckUnusedVar::isFunctionWithoutSideEffects(const Function& func, const To`
`1608`	`1609`	`}`
`1609`	`1610`
`1610`	`1611`	`bool sideEffectReturnFound = false;`
`1611`		`- for (Token* bodyToken = func.functionScope->bodyStart->next(); bodyToken != func.functionScope->bodyEnd;`
`1612`		`- bodyToken = bodyToken->next())`
`1613`		`- {`
	`1612`	`+ for (Token* bodyToken = func.functionScope->bodyStart->next(); bodyToken != func.functionScope->bodyEnd;`
	`1613`	`+ bodyToken = bodyToken->next()) {`
`1614`	`1614`	`const Variable* bodyVariable = bodyToken->variable();`
`1615`	`1615`	`if (bodyVariable) {`
`1616`	`1616`	`// check variable for side-effects`
`1617`	`1617`	`if (!isVariableWithoutSideEffects(*bodyVariable)) {`
`1618`	`1618`	`return false;`
`1619`	`1619`	`}`
`1620`	`1620`	`// check if global variable is changed`
`1621`		`- if (bodyVariable->isGlobal()) {`
	`1621`	`+ if (bodyVariable->isGlobal()) {`
`1622`	`1622`	`return false; // TODO: analyze global variable usage`
`1623`	`1623`	`}`
`1624`	`1624`	`}`
`@@ -1645,7 +1645,7 @@ bool CheckUnusedVar::isFunctionWithoutSideEffects(const Function& func, const To`
`1645`	`1645`	`}`
`1646`	`1646`	`// simple one-token return`
`1647`	`1647`	`const Variable* returnVariable = returnValueToken->variable();`
`1648`		`- if (returnValueToken->isLiteral() \|\|`
	`1648`	`+ if (returnValueToken->isLiteral() \|\|`
`1649`	`1649`	`(returnVariable && isVariableWithoutSideEffects(*returnVariable))) {`
`1650`	`1650`	`continue;`
`1651`	`1651`	`}`