Ticket #8255: Don't crash upon invalid code while checking conditions.

simartin · simartin · commit cbf0b13b3e18 · 2017-11-25T08:22:39.000+01:00
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
@@ -8310,6 +8310,8 @@ const Token * Tokenizer::findGarbageCode() const
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
         if (Token::Match(tok, "%cop% %or%|%oror%|/|%"))
             return tok;
+        if (Token::Match(tok, ";|(|[ %comp%"))
+            return tok;
     }
 
     // Code must not start with an arithmetical operand
diff --git a/test/testgarbage.cpp b/test/testgarbage.cpp
@@ -218,6 +218,7 @@ class TestGarbage : public TestFixture {
         TEST_CASE(garbageCode185); // #6011
         TEST_CASE(garbageCode186); // #8151
         TEST_CASE(garbageCode187);
+        TEST_CASE(garbageCode188);
         TEST_CASE(garbageValueFlow);
         TEST_CASE(garbageSymbolDatabase);
         TEST_CASE(garbageAST);
@@ -562,12 +563,12 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode36() { // #6334
-        checkCode("{ } < class template < > , { = } ; class... >\n"
-                  "struct Y { }\n"
-                  "class Types { }\n"
-                  "( X < int > \"uses template\" ) ( < ( ) \"uses ;"
-                  "( int int ::primary \"uses template\" ) int double \"uses )"
-                  "::primary , \"uses template\" ;\n");
+        ASSERT_THROW(checkCode("{ } < class template < > , { = } ; class... >\n"
+                     "struct Y { }\n"
+                     "class Types { }\n"
+                     "( X < int > \"uses template\" ) ( < ( ) \"uses ;"
+                     "( int int ::primary \"uses template\" ) int double \"uses )"
+                     "::primary , \"uses template\" ;\n"), InternalError);
     }
 
     void garbageCode37() {
@@ -710,7 +711,7 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode77() { // #6755
-        checkCode("void foo (int **p) { { { };>= } } unsigned *d = (b b--) --*d");
+        ASSERT_THROW(checkCode("void foo (int **p) { { { };>= } } unsigned *d = (b b--) --*d"), InternalError);
     }
 
     void garbageCode78() { // #6756
@@ -823,7 +824,7 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode105() { // #6859
-        checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }");
+        ASSERT_THROW(checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }"), InternalError);
     }
 
     void garbageCode106() { // #6880
@@ -843,7 +844,7 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode110() { //  #6902 "segmentation fault (invalid code) in CheckStl::string_c_str"
-        checkCode("( *const<> ( size_t ) ; foo ) { } * ( *const ( size_t ) ( ) ;> foo )< { }");
+        ASSERT_THROW(checkCode("( *const<> ( size_t ) ; foo ) { } * ( *const ( size_t ) ( ) ;> foo )< { }"), InternalError);
     }
 
     void garbageCode111() { //  #6907
@@ -866,7 +867,7 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode116() { // #5356
-        checkCode("struct template<int { = }; > struct B { }; B < 0 > b;");
+        ASSERT_THROW(checkCode("struct template<int { = }; > struct B { }; B < 0 > b;"), InternalError);
     }
 
     void garbageCode117() { // #6121
@@ -1097,7 +1098,7 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode144() { // #6865
-        checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;");
+        ASSERT_THROW(checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;"), InternalError);
     }
 
     void garbageCode146() { // #7081
@@ -1432,6 +1433,10 @@ class TestGarbage : public TestFixture {
         ASSERT_THROW(checkCode(inp), InternalError);
     }
 
+    void garbageCode188() { // #8255
+        ASSERT_THROW(checkCode("{z r(){(){for(;<(x);){if(0==0)}}}}"), InternalError);
+    }
+
     void syntaxErrorFirstToken() {
         ASSERT_THROW(checkCode("&operator(){[]};"), InternalError); // #7818
         ASSERT_THROW(checkCode("*(*const<> (size_t); foo) { } *(*const (size_t)() ; foo) { }"), InternalError); // #6858

Original file line number	Diff line number	Diff line change
`@@ -8310,6 +8310,8 @@ const Token * Tokenizer::findGarbageCode() const`
`8310`	`8310`	`for (const Token *tok = tokens(); tok; tok = tok->next()) {`
`8311`	`8311`	`if (Token::Match(tok, "%cop% %or%\|%oror%\|/\|%"))`
`8312`	`8312`	`return tok;`
	`8313`	`+ if (Token::Match(tok, ";\|(\|[ %comp%"))`
	`8314`	`+ return tok;`
`8313`	`8315`	`}`
`8314`	`8316`
`8315`	`8317`	`// Code must not start with an arithmetical operand`
Original file line number	Diff line number	Diff line change
`@@ -218,6 +218,7 @@ class TestGarbage : public TestFixture {`
`218`	`218`	`TEST_CASE(garbageCode185); // #6011`
`219`	`219`	`TEST_CASE(garbageCode186); // #8151`
`220`	`220`	`TEST_CASE(garbageCode187);`
	`221`	`+ TEST_CASE(garbageCode188);`
`221`	`222`	`TEST_CASE(garbageValueFlow);`
`222`	`223`	`TEST_CASE(garbageSymbolDatabase);`
`223`	`224`	`TEST_CASE(garbageAST);`
`@@ -562,12 +563,12 @@ class TestGarbage : public TestFixture {`
`562`	`563`	`}`
`563`	`564`
`564`	`565`	`void garbageCode36() { // #6334`
`565`		`- checkCode("{ } < class template < > , { = } ; class... >\n"`
`566`		`- "struct Y { }\n"`
`567`		`- "class Types { }\n"`
`568`		`- "( X < int > \"uses template\" ) ( < ( ) \"uses ;"`
`569`		`- "( int int ::primary \"uses template\" ) int double \"uses )"`
`570`		`- "::primary , \"uses template\" ;\n");`
	`566`	`+ ASSERT_THROW(checkCode("{ } < class template < > , { = } ; class... >\n"`
	`567`	`+ "struct Y { }\n"`
	`568`	`+ "class Types { }\n"`
	`569`	`+ "( X < int > \"uses template\" ) ( < ( ) \"uses ;"`
	`570`	`+ "( int int ::primary \"uses template\" ) int double \"uses )"`
	`571`	`+ "::primary , \"uses template\" ;\n"), InternalError);`
`571`	`572`	`}`
`572`	`573`
`573`	`574`	`void garbageCode37() {`
`@@ -710,7 +711,7 @@ class TestGarbage : public TestFixture {`
`710`	`711`	`}`
`711`	`712`
`712`	`713`	`void garbageCode77() { // #6755`
`713`		`- checkCode("void foo (int *p) { { { };>= } } unsigned d = (b b--) --*d");`
	`714`	`+ ASSERT_THROW(checkCode("void foo (int *p) { { { };>= } } unsigned d = (b b--) --*d"), InternalError);`
`714`	`715`	`}`
`715`	`716`
`716`	`717`	`void garbageCode78() { // #6756`
`@@ -823,7 +824,7 @@ class TestGarbage : public TestFixture {`
`823`	`824`	`}`
`824`	`825`
`825`	`826`	`void garbageCode105() { // #6859`
`826`		`- checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }");`
	`827`	`+ ASSERT_THROW(checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }"), InternalError);`
`827`	`828`	`}`
`828`	`829`
`829`	`830`	`void garbageCode106() { // #6880`
`@@ -843,7 +844,7 @@ class TestGarbage : public TestFixture {`
`843`	`844`	`}`
`844`	`845`
`845`	`846`	`void garbageCode110() { // #6902 "segmentation fault (invalid code) in CheckStl::string_c_str"`
`846`		`- checkCode("( const<> ( size_t ) ; foo ) { } ( *const ( size_t ) ( ) ;> foo )< { }");`
	`847`	`+ ASSERT_THROW(checkCode("( const<> ( size_t ) ; foo ) { } ( *const ( size_t ) ( ) ;> foo )< { }"), InternalError);`
`847`	`848`	`}`
`848`	`849`
`849`	`850`	`void garbageCode111() { // #6907`
`@@ -866,7 +867,7 @@ class TestGarbage : public TestFixture {`
`866`	`867`	`}`
`867`	`868`
`868`	`869`	`void garbageCode116() { // #5356`
`869`		`- checkCode("struct template<int { = }; > struct B { }; B < 0 > b;");`
	`870`	`+ ASSERT_THROW(checkCode("struct template<int { = }; > struct B { }; B < 0 > b;"), InternalError);`
`870`	`871`	`}`
`871`	`872`
`872`	`873`	`void garbageCode117() { // #6121`
`@@ -1097,7 +1098,7 @@ class TestGarbage : public TestFixture {`
`1097`	`1098`	`}`
`1098`	`1099`
`1099`	`1100`	`void garbageCode144() { // #6865`
`1100`		`- checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;");`
	`1101`	`+ ASSERT_THROW(checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;"), InternalError);`
`1101`	`1102`	`}`
`1102`	`1103`
`1103`	`1104`	`void garbageCode146() { // #7081`
`@@ -1432,6 +1433,10 @@ class TestGarbage : public TestFixture {`
`1432`	`1433`	`ASSERT_THROW(checkCode(inp), InternalError);`
`1433`	`1434`	`}`
`1434`	`1435`
	`1436`	`+ void garbageCode188() { // #8255`
	`1437`	`+ ASSERT_THROW(checkCode("{z r(){(){for(;<(x);){if(0==0)}}}}"), InternalError);`
	`1438`	`+ }`
	`1439`	`+`
`1435`	`1440`	`void syntaxErrorFirstToken() {`
`1436`	`1441`	`ASSERT_THROW(checkCode("&operator(){[]};"), InternalError); // #7818`
`1437`	`1442`	`ASSERT_THROW(checkCode("(const<> (size_t); foo) { } (const (size_t)() ; foo) { }"), InternalError); // #6858`