/* * Cppcheck - A tool for static C/C++ code analysis * Copyright (C) 2007-2009 Daniel Marjamäki and 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 . */ #include "testsuite.h" #define private public #include "tokenize.h" #undef private #include "token.h" #include extern std::ostringstream errout; class TestSimplifyTokens : public TestFixture { public: TestSimplifyTokens() : TestFixture("TestSimplifyTokens") { } private: void run() { TEST_CASE(cast); TEST_CASE(iftruefalse); TEST_CASE(combine_strings); TEST_CASE(double_plus); TEST_CASE(redundant_plus); TEST_CASE(parantheses1); TEST_CASE(paranthesesVar); // Remove redundant parantheses around variable .. "( %var% )" TEST_CASE(declareVar); TEST_CASE(declareArray); TEST_CASE(dontRemoveIncrement); TEST_CASE(removePostIncrement); TEST_CASE(removePreIncrement); TEST_CASE(elseif1); TEST_CASE(ifa_ifa); // "if (a) { if (a) .." => "if (a) { if (1) .." TEST_CASE(sizeof1); TEST_CASE(sizeof2); TEST_CASE(sizeof3); TEST_CASE(sizeof4); TEST_CASE(sizeof5); TEST_CASE(sizeof6); TEST_CASE(sizeof7); TEST_CASE(sizeof8); TEST_CASE(sizeof9); TEST_CASE(sizeof10); TEST_CASE(sizeof11); TEST_CASE(sizeof12); TEST_CASE(sizeof13); TEST_CASE(sizeof14); TEST_CASE(sizeof15); TEST_CASE(sizeof16); TEST_CASE(sizeof17); TEST_CASE(casting); TEST_CASE(strlen1); TEST_CASE(template1); TEST_CASE(template2); TEST_CASE(template3); TEST_CASE(template4); TEST_CASE(template5); TEST_CASE(template6); TEST_CASE(template7); TEST_CASE(template8); TEST_CASE(template9); TEST_CASE(template10); TEST_CASE(template11); TEST_CASE(template12); TEST_CASE(template13); TEST_CASE(template14); TEST_CASE(template15); TEST_CASE(template16); TEST_CASE(template17); TEST_CASE(template18); TEST_CASE(template_default_parameter); TEST_CASE(template_default_type); TEST_CASE(template_typename); TEST_CASE(namespaces); // Assignment in condition.. TEST_CASE(ifassign1); TEST_CASE(whileAssign); // "if(0==x)" => "if(!x)" TEST_CASE(ifnot); TEST_CASE(combine_wstrings); // Simplify "not" to "!" (#345) TEST_CASE(not1); // Simplify "and" to "&&" (#620) TEST_CASE(and1); TEST_CASE(comma_keyword); TEST_CASE(remove_comma); // Simplify "?:" TEST_CASE(conditionOperator); // Simplify calculations TEST_CASE(calculations); // Simplify goto.. TEST_CASE(goto1); // Simplify nested strcat() calls TEST_CASE(strcat1); TEST_CASE(strcat2); // Syntax error TEST_CASE(argumentsWithSameName) TEST_CASE(simplifyAtol) TEST_CASE(simplifyHexInString) TEST_CASE(simplifyTypedef1) TEST_CASE(simplifyTypedef2) TEST_CASE(simplifyTypedef3) TEST_CASE(simplifyTypedef4) TEST_CASE(simplifyTypedef5) TEST_CASE(simplifyTypedef6) TEST_CASE(simplifyTypedef7); TEST_CASE(simplifyTypedef8); TEST_CASE(simplifyTypedef9); TEST_CASE(simplifyTypedef10); TEST_CASE(simplifyTypedef11); TEST_CASE(simplifyTypedef12); TEST_CASE(simplifyTypedef13); TEST_CASE(simplifyTypedef14); TEST_CASE(simplifyTypedef15); TEST_CASE(simplifyTypedef16); TEST_CASE(simplifyTypedef17); TEST_CASE(simplifyTypedef18); // typedef vector a; TEST_CASE(simplifyTypedef19); TEST_CASE(simplifyTypedef20); TEST_CASE(simplifyTypedef21); TEST_CASE(simplifyTypedef22); TEST_CASE(simplifyTypedef23); TEST_CASE(simplifyTypedef24); TEST_CASE(simplifyTypedef25); TEST_CASE(simplifyTypedef26); TEST_CASE(simplifyTypedef27); TEST_CASE(simplifyTypedef28); TEST_CASE(simplifyTypedef29); TEST_CASE(reverseArraySyntax) TEST_CASE(simplify_numeric_condition) TEST_CASE(pointeralias); TEST_CASE(reduceConstness); // simplify "while (0)" TEST_CASE(while0); TEST_CASE(while1); TEST_CASE(enum1); TEST_CASE(enum2); TEST_CASE(enum3); TEST_CASE(enum4); // remove "std::" on some standard functions TEST_CASE(removestd); // Tokenizer::simplifyInitVar TEST_CASE(simplifyInitVar); } std::string tok(const char code[], bool simplify = true) { errout.str(""); Settings settings; Tokenizer tokenizer(&settings, this); std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); if (simplify) tokenizer.simplifyTokenList(); tokenizer.validate(); std::string ret; for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) { if (tok != tokenizer.tokens()) ret += " "; ret += tok->str(); } return ret; } void cast() { ASSERT_EQUALS("if ( ! p )", tok("if (p == (char *)0)")); ASSERT_EQUALS("return str ;", tok("return (char *)str;")); { const char code[] = "static void crash()\n" "{\n" " goto err_exit;\n" "err_exit:\n" " (void)foo();\n" "}\n"; const char expected[] = "static void crash ( ) " "{ foo ( ) ; return ; foo ( ) ; }"; ASSERT_EQUALS(expected, tok(code)); } ASSERT_EQUALS("if ( * a )", tok("if ((char)*a)")); ASSERT_EQUALS("if ( & a )", tok("if ((int)&a)")); ASSERT_EQUALS("if ( * a )", tok("if ((unsigned int)(unsigned char)*a)")); ASSERT_EQUALS("class A { A operator * ( int ) ; } ;", tok("class A { A operator *(int); };")); ASSERT_EQUALS("class A { A operator * ( int ) const ; } ;", tok("class A { A operator *(int) const; };")); } void iftruefalse() { { const char code1[] = " void f() { int a; bool use = false; if( use ) { a=0; } else {a=1;} }"; const char code2[] = " void f() { int a; bool use = false; {a=1;} }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; bool use = true; if( use ) { a=0; } else {a=1;} }"; const char code2[] = " void f() { int a; bool use = true; { a=0; } }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; int use = 5; if( use ) { a=0; } else {a=1;} }"; const char code2[] = " void f() { int a; int use = 5; { a=0; } }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; int use = 0; if( use ) { a=0; } else {a=1;} }"; const char code2[] = " void f() { int a; int use = 0; {a=1;} }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; bool use = false; if( use ) a=0; else a=1; int c=1; }"; const char code2[] = " void f() { int a; bool use = false; { a=1; } int c=1; }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; bool use = true; if( use ) a=0; else a=1; int c=1; }"; const char code2[] = " void f() { int a; bool use = true; { a=0; } int c=1; }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; bool use = false; if( use ) a=0; else if( bb ) a=1; int c=1; }"; const char code2[] = " void f ( ) { int a ; bool use ; use = false ; { if ( bb ) { a = 1 ; } } int c ; c = 1 ; }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { int a; bool use = true; if( use ) a=0; else if( bb ) a=1; int c=1; }"; const char code2[] = " void f() { int a; bool use = true; { a=0;} int c=1; }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = "void f() { int a; bool use = true; if( use ) a=0; else if( bb ) a=1; else if( cc ) a=33; else { gg = 0; } int c=1; }"; const char code2[] = "void f ( ) { int a ; ; ; { a = 0 ; } int c ; c = 1 ; }"; ASSERT_EQUALS(code2, tok(code1)); } { const char code1[] = " void f() { if( aa ) { a=0; } else if( true ) a=1; else { a=2; } }"; const char code2[] = " void f ( ) { if ( aa ) { a = 0 ; } else { { a = 1 ; } } }"; ASSERT_EQUALS(tok(code2), tok(code1)); } { const char code1[] = " void f() { if( aa ) { a=0; } else if( false ) a=1; else { a=2; } }"; const char code2[] = " void f ( ) { if ( aa ) { a = 0 ; } else { { a = 2 ; } } }"; ASSERT_EQUALS(tok(code2), tok(code1)); } } void combine_strings() { const char code1[] = "void foo()\n" "{\n" "const char *a =\n" "{\n" "\"hello \"\n" "\"world\"\n" "};\n" "}\n"; const char code2[] = "void foo()\n" "{\n" "const char *a =\n" "{\n" "\"hello world\"\n" "};\n" "}\n"; ASSERT_EQUALS(tok(code2), tok(code1)); } void combine_wstrings() { const char code1[] = "void foo()\n" "{\n" "const wchar_t *a =\n" "{\n" "L\"hello \"\n" "L\"world\"\n" "};\n" "}\n"; const char code2[] = "void foo()\n" "{\n" "const wchar_t *a =\n" "{\n" "\"hello world\"\n" "};\n" "}\n"; ASSERT_EQUALS(tok(code2), tok(code1)); } void double_plus() { { const char code1[] = "void foo( int a )\n" "{\n" "a++;\n" "a--;\n" "++a;\n" "--a;\n" "}\n"; ASSERT_EQUALS("void foo ( int a ) { a ++ ; a -- ; ++ a ; -- a ; }", tok(code1)); } { const char code1[] = "void foo( int a )\n" "{\n" "a=a+a;\n" "}\n"; ASSERT_EQUALS("void foo ( int a ) { a = a + a ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a+++b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a ++ + b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a---b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a -- - b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a--+b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a -- + b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a++-b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a ++ - b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a+--b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a + -- b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a-++b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a - ++ b ; }", tok(code1)); } } void redundant_plus() { { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a + + b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a + + + b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a + - b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a - + b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a - - b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a - + - b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1)); } { const char code1[] = "void foo( int a, int b )\n" "{\n" "a=a - - - b;\n" "}\n"; ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1)); } } void parantheses1() { ASSERT_EQUALS("<= 110 ;", tok("<= (10+100);")); } void paranthesesVar() { // remove parantheses.. ASSERT_EQUALS("= p ;", tok("= (p);")); ASSERT_EQUALS("if ( a < p ) { }", tok("if(a<(p)){}")); ASSERT_EQUALS("void f ( ) { int p ; if ( p == -1 ) { } }", tok("void f(){int p; if((p)==-1){}}")); ASSERT_EQUALS("void f ( ) { int p ; if ( p == -1 ) { } }", tok("void f(){int p; if(-1==(p)){}}")); ASSERT_EQUALS("void f ( ) { int p ; if ( p ) { } }", tok("void f(){int p; if((p)){}}")); ASSERT_EQUALS("return p ;", tok("return (p);")); ASSERT_EQUALS("void f ( ) { int * p ; if ( ! * p ) { } }", tok("void f(){int *p; if (*(p) == 0) {}}")); ASSERT_EQUALS("void f ( ) { int * p ; if ( ! * p ) { } }", tok("void f(){int *p; if (*p == 0) {}}")); ASSERT_EQUALS("void f ( ) { int p ; p = 1 ; }", tok("void f(){int p; (p) = 1;}")); ASSERT_EQUALS("void f ( ) { int p [ 10 ] ; p [ 0 ] = 1 ; }", tok("void f(){int p[10]; (p)[0] = 1;}")); ASSERT_EQUALS("void f ( ) { int p ; if ( ! p ) { } }", tok("void f(){int p; if ((p) == 0) {}}")); ASSERT_EQUALS("void f ( ) { int * p ; * p = 1 ; }", tok("void f(){int *p; *(p) = 1;}")); ASSERT_EQUALS("void f ( ) { int p ; if ( p ) { } p = 1 ; }", tok("void f(){int p; if ( p ) { } (p) = 1;}")); // keep parantheses.. ASSERT_EQUALS("= a ;", tok("= (char)a;")); ASSERT_EQUALS("cast < char * > ( p )", tok("cast(p)")); ASSERT_EQUALS("return ( a + b ) * c ;", tok("return (a+b)*c;")); ASSERT_EQUALS("void f ( ) { int p ; if ( 2 * p == 0 ) { } }", tok("void f(){int p; if (2*p == 0) {}}")); ASSERT_EQUALS("void f ( ) { DIR * f ; f = opendir ( dirname ) ; if ( closedir ( f ) ) { } }", tok("void f(){DIR * f = opendir(dirname);if (closedir(f)){}}")); ASSERT_EQUALS("void foo ( int p ) { if ( 0 <= p ) { ; } }", tok("void foo(int p){if((p)>=0);}")); } void declareVar() { const char code[] = "void f ( ) { char str [ 100 ] = \"100\" ; }"; ASSERT_EQUALS(code, tok(code)); } void declareArray() { const char code[] = "void f ( ) { char str [ ] = \"100\" ; }"; const char expected[] = "void f ( ) { char * str ; str = \"100\" ; }"; ASSERT_EQUALS(expected, tok(code)); } void dontRemoveIncrement() { { const char code[] = "void f(int a)\n" "{\n" " if (a > 10)\n" " a = 5;\n" " else\n" " a = 10;\n" " a++;\n" "}\n"; ASSERT_EQUALS("void f ( int a ) { if ( 10 < a ) { a = 5 ; } else { a = 10 ; } a ++ ; }", tok(code)); } { const char code[] = "void f(int a)\n" "{\n" " if (a > 10)\n" " a = 5;\n" " else\n" " a = 10;\n" " ++a;\n" "}\n"; ASSERT_EQUALS("void f ( int a ) { if ( 10 < a ) { a = 5 ; } else { a = 10 ; } ++ a ; }", tok(code)); } } void removePostIncrement() { const char code[] = "void f()\n" "{\n" " unsigned int c = 0;\n" " c++;\n" " if (c>0) { c++; }\n" " c++;\n" "}\n"; ASSERT_EQUALS("void f ( ) { int c ; c = 3 ; ; { ; } ; }", tok(code)); } void removePreIncrement() { { const char code[] = "void f()\n" "{\n" " unsigned int c = 0;\n" " ++c;\n" " if (c>0) { ++c; }\n" " ++c;\n" "}\n"; ASSERT_EQUALS("void f ( ) { int c ; c = 3 ; ; { ; } ; }", tok(code)); } { const char code[] = "void f()\n" "{\n" " char a[] = \"p\";\n" " ++a[0];\n" "}\n"; ASSERT_EQUALS("void f ( ) { char * a ; a = \"p\" ; ++ a [ 0 ] ; }", tok(code)); } } std::string elseif(const char code[]) { std::istringstream istr(code); Tokenizer tokenizer; tokenizer.createTokens(istr); tokenizer.elseif(); return tokenizer.tokens()->stringifyList(false); } void elseif1() { const char code[] = "else if(ab) { cd } else { ef }gh"; ASSERT_EQUALS("\n\n##file 0\n1: else { if ( ab ) { cd } else { ef } } gh\n", elseif(code)); // syntax error: assert there is no segmentation fault ASSERT_EQUALS("\n\n##file 0\n1: else if ( x ) { }\n", elseif("else if (x) { }")); { const char src[] = "void f(int g,int f) {\n" "if(g==1) {poo();}\n" "else if( g == 2 )\n" "{\n" " if( f == 0 ){coo();}\n" " else if( f==1)\n" " goo();\n" "}\n" "}"; const char expected[] = "void f ( int g , int f ) " "{ " "if ( g == 1 ) { poo ( ) ; } " "else { " "if ( g == 2 ) " "{ " "if ( ! f ) { coo ( ) ; } " "else { " "if ( f == 1 ) " "{ " "goo ( ) ; " "} " "} " "} " "} " "}"; ASSERT_EQUALS(tok(expected), tok(src)); } } void ifa_ifa() { ASSERT_EQUALS("int a ; if ( a ) { { ab } cd }", tok("int a ; if (a) { if (a) { ab } cd }", true)); ASSERT_EQUALS("int a ; if ( a ) { { ab } cd }", tok("int a ; if (unlikely(a)) { if (a) { ab } cd }", true)); } // Simplify 'sizeof'.. std::string sizeof_(const char code[]) { // tokenize.. Settings settings; Tokenizer tokenizer(&settings, this); std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); tokenizer.setVarId(); tokenizer.simplifyTokenList(); std::ostringstream ostr; for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) { if (tok->previous()) { ostr << " "; } ostr << tok->str(); } return ostr.str(); } unsigned int sizeofFromTokenizer(const char type[]) { Tokenizer tokenizer; std::istringstream istr(""); tokenizer.tokenize(istr, "test.cpp"); tokenizer.simplifyTokenList(); Token tok(0); tok.str(type); return tokenizer.sizeOfType(&tok); } void sizeof1() { ASSERT_EQUALS("struct ABC * abc ; abc = malloc ( 100 ) ;", tok("struct ABC *abc = malloc(sizeof(*abc));")); ASSERT_EQUALS("struct ABC * abc ; abc = malloc ( 100 ) ;", tok("struct ABC *abc = malloc(sizeof *abc );")); } void sizeof2() { const char code[] = "void foo()\n" "{\n" " int i[4];\n" " sizeof(i);\n" " sizeof(*i);\n" "}\n"; ASSERT_EQUALS("void foo ( ) { int i [ 4 ] ; 16 ; 4 ; }", sizeof_(code)); } void sizeof3() { const char code[] = "static int i[4];\n" "void f()\n" "{\n" " int i[10];\n" " sizeof(i);\n" "}\n"; ASSERT_EQUALS("static int i [ 4 ] ; void f ( ) { int i [ 10 ] ; 40 ; }", sizeof_(code)); } void sizeof4() { { const char code[] = "int i[10];\n" "sizeof(i[0]);\n"; ASSERT_EQUALS("int i [ 10 ] ; 4 ;", sizeof_(code)); } { const char code[] = "int i[10];\n" "sizeof i[0];\n"; ASSERT_EQUALS("int i [ 10 ] ; 4 ;", sizeof_(code)); } } void sizeof5() { const char code[] = "const char * names[2];" "for (int i = 0; i < sizeof(names[0]); i++)" "{}"; std::ostringstream expected; expected << "const char * names [ 2 ] ; for ( int i = 0 ; i < " << sizeofFromTokenizer("*") << " ; i ++ ) { }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } void sizeof6() { const char code[] = ";int i;\n" "sizeof(i);\n"; std::ostringstream expected; expected << "; int i ; " << sizeof(int) << " ;"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } void sizeof7() { const char code[] = ";INT32 i[10];\n" "sizeof(i[0]);\n"; ASSERT_EQUALS("; INT32 i [ 10 ] ; sizeof ( i [ 0 ] ) ;", sizeof_(code)); } void sizeof8() { { const char code[] = "void f()\n" "{\n" " char* ptrs[2];\n" " int a = sizeof( ptrs );\n" "}\n"; std::ostringstream oss; oss << (sizeofFromTokenizer("*") * 2); ASSERT_EQUALS("void f ( ) { char * ptrs [ 2 ] ; int a ; a = " + oss.str() + " ; }", sizeof_(code)); } { const char code[] = "void f()\n" "{\n" " char* ptrs[55];\n" " int a = sizeof( ptrs );\n" "}\n"; std::ostringstream oss; oss << (sizeofFromTokenizer("*") * 55); ASSERT_EQUALS("void f ( ) { char * ptrs [ 55 ] ; int a ; a = " + oss.str() + " ; }", sizeof_(code)); } { const char code[] = "void f()\n" "{\n" " char* ptrs;\n" " int a = sizeof( ptrs );\n" "}\n"; std::ostringstream oss; oss << sizeofFromTokenizer("*"); ASSERT_EQUALS("void f ( ) { ; int a ; a = " + oss.str() + " ; }", sizeof_(code)); } } void sizeof9() { // ticket #487 { const char code[] = "; const char *str = \"1\"; sizeof(str);"; std::ostringstream expected; expected << "; const char * str ; str = \"1\" ; " << sizeofFromTokenizer("*") << " ;"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "; const char str[] = \"1\"; sizeof(str);"; std::ostringstream expected; expected << "; const char * str ; str = \"1\" ; " << sizeofFromTokenizer("char")*2 << " ;"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "; const char str[] = {'1'}; sizeof(str);"; const char str[] = {'1'}; std::ostringstream expected; expected << "; const char * str ; str = { '1' } ; " << sizeof(str) << " ;"; TODO_ASSERT_EQUALS(expected.str(), sizeof_(code)); } // ticket #716 - sizeof string { std::ostringstream expected; expected << "; " << (sizeof "123"); ASSERT_EQUALS(expected.str(), sizeof_("; sizeof \"123\"")); ASSERT_EQUALS(expected.str(), sizeof_("; sizeof(\"123\")")); } { const char code[] = "void f(char *a,char *b, char *c)" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( char * a , char * b , char * c ) { g ( " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "void f(char a,char b, char c)" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( char a , char b , char c ) { g ( " << sizeofFromTokenizer("char") << " , " << sizeofFromTokenizer("char") << " , " << sizeofFromTokenizer("char") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "void f(const char *a,const char *b, const char *c)" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( const char * a , const char * b , const char * c ) { g ( " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "void f(char a[10],char b[10], char c[10])" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( char a [ 10 ] , char b [ 10 ] , char c [ 10 ] ) { g ( " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "void f(const char a[10],const char b[10], const char c[10])" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( const char a [ 10 ] , " "const char b [ 10 ] , " "const char c [ 10 ] ) { g ( " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "void f(const char *a[10],const char *b[10], const char *c[10])" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( const char * a [ 10 ] , " "const char * b [ 10 ] , " "const char * c [ 10 ] ) { g ( " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { const char code[] = "void f(char *a[10],char *b[10], char *c[10])" "{g(sizeof(a),sizeof(b),sizeof(c));}"; std::ostringstream expected; expected << "void f ( char * a [ 10 ] , char * b [ 10 ] , char * c [ 10 ] ) { g ( " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }"; ASSERT_EQUALS(expected.str(), sizeof_(code)); } { std::ostringstream expected; expected << "; " << sizeof("\"quote\""); ASSERT_EQUALS(expected.str(), sizeof_("; sizeof(\"\\\"quote\\\"\")")); } { std::ostringstream expected; expected << "void f ( ) { char str [ 100 ] = \"100\" ; " << sizeofFromTokenizer("char")*100 << " }"; ASSERT_EQUALS(expected.str(), tok("void f ( ) { char str [ 100 ] = \"100\" ; sizeof ( str ) }")); } } void sizeof10() { // ticket #809 const char code[] = "int m ; " "compat_ulong_t um ; " "size_t size ; size = sizeof ( m ) / sizeof ( um ) ;"; ASSERT_EQUALS(code, tok(code)); } void sizeof11() { // ticket #827 const char code[] = "void f()\n" "{\n" " char buf2[4];\n" " sizeof buf2;\n" "}\n" "\n" "void g()\n" "{\n" " struct A a[2];\n" " char buf[32];\n" " sizeof buf;\n" "}"; const char expected[] = "void f ( ) " "{" " char buf2 [ 4 ] ;" " 4 ; " "} " "" "void g ( ) " "{" " struct A a [ 2 ] ;" " char buf [ 32 ] ;" " 32 ; " "}"; ASSERT_EQUALS(expected, tok(code)); } void sizeof12() { // ticket #827 const char code[] = "void f()\n" "{\n" " int *p;\n" " (sizeof *p);\n" "}"; const char expected[] = "void f ( ) " "{" " ;" " 4 ; " "}"; ASSERT_EQUALS(expected, tok(code)); } void sizeof13() { // ticket #851 const char code[] = "int main()\n" "{\n" " char *a;\n" " a = malloc(sizeof(*a));\n" "}\n" "\n" "struct B\n" "{\n" " char * b[2];\n" "};"; const char expected[] = "int main ( ) " "{" " char * a ;" " a = malloc ( 1 ) ; " "} " "struct B " "{" " char * b [ 2 ] ; " "} ;"; ASSERT_EQUALS(expected, tok(code)); } void sizeof14() { // ticket #954 const char code[] = "void f()\n" "{\n" " A **a;\n" " int aa = sizeof *(*a)->b;\n" "}\n"; const char expected[] = "void f ( ) " "{" " A * * a ;" " int aa ; aa = sizeof ( * ( * a ) . b ) ; " "}"; ASSERT_EQUALS(expected, tok(code)); } void sizeof15() { // ticket #1020 tok("void f()\n" "{\n" " int *n;\n" " sizeof *(n);\n" "}\n"); ASSERT_EQUALS("", errout.str()); } void sizeof16() { // ticket #1027 const char code[] = "void f()\n" "{\n" " int a;\n" " printf(\"%i\", sizeof a++);\n" "}\n"; ASSERT_EQUALS("void f ( ) { int a ; printf ( \"%i\" , sizeof ( a ++ ) ) ; }", tok(code)); ASSERT_EQUALS("", errout.str()); } void sizeof17() { // ticket #1050 const char code[] = "void f()\n" "{\n" " sizeof 1;\n" " while (0);\n" "}\n"; ASSERT_EQUALS("void f ( ) { sizeof ( 1 ) ; }", tok(code)); ASSERT_EQUALS("", errout.str()); } void casting() { { const char code[] = "void f()\n" "{\n" "for (int i = 0; i < static_cast(3); ++i) {}\n" "}\n"; const std::string expected("void f ( ) { for ( int i = 0 ; i < 3 ; ++ i ) { } }"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "void f()\n" "{\n" " p = const_cast qtu ();\n" "}\n"; const std::string expected("void f ( ) { p = const_cast < char * > qtu ( ) ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } { // ticket #645 const char code[] = "void f()\n" "{\n" " return dynamic_cast((bar()));\n" "}\n"; const std::string expected("void f ( ) { return bar ( ) ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } } void strlen1() { ASSERT_EQUALS("4", tok("strlen(\"abcd\")")); { const char code[] = "void f()\n" "{\n" " const char *s = \"abcd\";\n" " strlen(s);\n" "}\n"; const char expected[] = "void f ( ) " "{" " const char * s ;" " s = \"abcd\" ;" " 4 ; " "}"; ASSERT_EQUALS(expected, tok(code)); } { const char code[] = "void f()\n" "{\n" " const char s [ ] = \"abcd\";\n" " strlen(s);\n" "}\n"; const char expected[] = "void f ( ) " "{" " const char * s ;" " s = \"abcd\" ;" " 4 ; " "}"; ASSERT_EQUALS(expected, tok(code)); } } void template1() { const char code[] = "template void f(T val) { T a; }\n" "f(10);"; const std::string expected("; f ( 10 ) ; " "void f ( int val ) { ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template2() { const char code[] = "template class Fred { T a; };\n" "Fred fred;"; const std::string expected("; ; " "Fred fred ; " "class Fred { int a ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template3() { const char code[] = "template class Fred { T data[sz]; };\n" "Fred fred;"; const std::string expected("; ; " "Fred fred ; " "class Fred { float data [ 4 ] ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template4() { const char code[] = "template class Fred { Fred(); };\n" "Fred fred;"; const std::string expected("; ; " "Fred fred ; " "class Fred { Fred ( ) ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template5() { const char code[] = "template class Fred { };\n" "template Fred::Fred() { }\n" "Fred fred;"; const std::string expected("; ; " "; " "Fred fred ; " "class Fred { } " "Fred :: Fred ( ) { }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template6() { const char code[] = "template class Fred { };\n" "Fred fred1;\n" "Fred fred2;"; const std::string expected("; ;" " Fred fred1 ;" " Fred fred2 ;" " class Fred { }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template7() { // A template class that is not used => no simplification { const char code[] = "template \n" "class ABC\n" "{\n" "public:\n" " typedef ABC m;\n" "\n" "};\n"; const std::string expected("; ;"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "template class ABC {\n" "public:\n" " typedef std::vector type;\n" "};\n" "int main() {\n" " ABC::type v;\n" " v.push_back(4);\n" " return 0;\n" "}\n"; const std::string expected("; ; " "int main ( ) { " "std :: vector < int > v ; " "v . push_back ( 4 ) ; " "return 0 ; " "}"); TODO_ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "template class ABC {\n" "public:\n" " typedef std::vector type;\n" " void f()\n" " {\n" " ABC::type v;\n" " v.push_back(4);\n" " }\n" "};\n"; const std::string expected("; ;"); ASSERT_EQUALS(expected, sizeof_(code)); } } // Template definitions but no usage => no expansion void template8() { const char code[] = "template class A;\n" "template class B;\n" "\n" "typedef A x;\n" "typedef B y;\n" "\n" "template class A {\n" " void f() {\n" " B a = B::g();\n" " T b = 0;\n" " if (b)\n" " b = 0;\n" " }\n" "};\n" "\n" "template inline B h() { return B(); }\n"; ASSERT_EQUALS("; ; ; ; ; ; ;", sizeof_(code)); ASSERT_EQUALS("class A { ; } ;", sizeof_("class A{ template int foo(T d);};")); } void template9() { const char code[] = "template < typename T > class A { } ;\n" "\n" "void f ( ) {\n" " A a ;\n" "}\n" "\n" "template < typename T >\n" "class B {\n" " void g ( ) {\n" " A < T > b = A < T > :: h ( ) ;\n" " }\n" "} ;\n"; // The expected result.. std::string expected("; ; void f ( ) { A a ; } ; ; class A { }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template10() { const char code[] = "template T * foo()\n" "{ return new T[ui]; }\n" "\n" "void f ( )\n" "{\n" " foo<3,int>();\n" "}\n"; // The expected result.. const std::string expected("; " "void f ( ) " "{" " foo<3,int> ( ) ; " "} " "int * foo<3,int> ( ) { return new int [ 3 ] ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template11() { const char code[] = "template T * foo()\n" "{ return new T[ui]; }\n" "\n" "void f ( )\n" "{\n" " char * p = foo<3,char>();\n" "}\n"; // The expected result.. const std::string expected("; " "void f ( ) " "{" " char * p ; p = foo<3,char> ( ) ; " "} " "char * foo<3,char> ( ) { return new char [ 3 ] ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template12() { const char code[] = "template \n" "class A : public B\n" "{ };\n" "\n" "void f()\n" "{\n" " A<12,12,11> a;\n" "}\n"; // The expected result.. const std::string expected("; ; " "void f ( ) " "{" " A<12,12,11> a ; " "} " "class A<12,12,11> : public B < 12 , 12 , 0 > " "{ }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template13() { const char code[] = "class BB {};\n" "\n" "template \n" "class AA\n" "{\n" "public:\n" " static AA create(T* newObject);\n" "};\n" "\n" "class CC { public: CC(AA, int) {} };\n" "\n" "class XX {\n" " AA y;\n" "public:\n" " XX();\n" "};\n" "\n" "XX::XX():\n" " y(AA::create(new CC(AA(), 0)))\n" " {}\n"; // Just run it and check that there are not assertions. sizeof_(code); } void template14() { const char code[] = "template <> void foo()\n" "{ x(); }\n" "\n" "int main()\n" "{\n" "foo();\n" "}\n"; // The expected result.. const std::string expected("void foo ( ) " "{ x ( ) ; } " "int main ( ) " "{ foo ( ) ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template15() { const char code[] = "template void a()\n" "{\n" " a();\n" "}\n" "\n" "template <> void a<0>()\n" "{ }\n" "\n" "int main()\n" "{\n" " a<2>();\n" " return 0;\n" "}\n"; // The expected result.. const std::string expected("; " "void a<0> ( ) { } " "int main ( ) " "{ a<2> ( ) ; return 0 ; } " "void a<2> ( ) { a<1> ( ) ; } " "void a<1> ( ) { a<0> ( ) ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template16() { const char code[] = "template void a()\n" "{ }\n" "\n" "template void b()\n" "{ a(); }\n" "\n" "int main()\n" "{\n" " b<2>();\n" " return 0;\n" "}\n"; // The expected result.. const std::string expected("; " "; " "int main ( ) { b<2> ( ) ; return 0 ; } " "void b<2> ( ) { a<2> ( ) ; } " "void a<2> ( ) { }"); TODO_ASSERT_EQUALS(expected, sizeof_(code)); } void template17() { const char code[] = "template\n" "class Fred\n" "{\n" " template\n" " static shared_ptr< Fred > CreateFred()\n" " {\n" " }\n" "};\n" "\n" "shared_ptr i;\n"; // Assert that there are not segmentation fault.. sizeof_(code); } void template18() { const char code[] = "template class foo { T a; };\n" "foo *f;"; const std::string expected("; ; " "foo * f ; " "class foo { int a ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } void template_default_parameter() { { const char code[] = "template \n" "class A\n" "{ T ar[n]; };\n" "\n" "void f()\n" "{\n" " A a1;\n" " A a2;\n" "}\n"; // The expected result.. const std::string expected("; ; " "void f ( ) " "{" " A a1 ;" " A a2 ; " "} " "class A " "{ int ar [ 2 ] ; } " "class A " "{ int ar [ 3 ] ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "template \n" "class A\n" "{ T ar[n1+n2]; };\n" "\n" "void f()\n" "{\n" " A a1;\n" " A a2;\n" "}\n"; // The expected result.. const std::string expected("; ; " "void f ( ) " "{" " A a1 ;" " A a2 ; " "} " "class A " "{ int ar [ 5 ] ; }"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "template \n" "class A\n" "{ T ar[n]; };\n" "\n" "void f()\n" "{\n" " A a1;\n" " A a2;\n" "}\n"; // The expected result.. const std::string expected("template < class T , int n >" " class A" " { T ar [ n ] ; } ;" " void f ( )" " {" " A a1 ;" " A a2 ;" " }" " class A" " { int ar [ 2 ] ; }" " class A" " { int ar [ 3 ] ; }"); TODO_ASSERT_EQUALS(expected, sizeof_(code)); } } void template_default_type() { const char code[] = "template \n" "class A\n" "{\n" "public:\n" " void foo() {\n" " int a;\n" " a = static_cast(a);\n" " }\n" "};\n" "\n" "template \n" "class B\n" "{\n" "protected:\n" " A a;\n" "};\n" "\n" "class C\n" " : public B\n" "{\n" "};\n"; errout.str(""); Settings settings; Tokenizer tokenizer(&settings, this); std::istringstream istr(code); tokenizer.tokenize(istr, "file1.cpp"); tokenizer.simplifyTokenList(); //ASSERT_EQUALS("[file1.cpp:15]: (error) Internal error: failed to instantiate template. The checking continues anyway.\n", errout.str()); ASSERT_EQUALS("", errout.str()); } void template_typename() { const char code[] = "template \n" "void foo(typename T::t *)\n" "{ }"; // The expected result.. const std::string expected(";"); ASSERT_EQUALS(expected, sizeof_(code)); } void namespaces() { { const char code[] = "using namespace std; namespace a{ namespace b{ void f(){} } }"; const std::string expected("using namespace std ; void f ( ) { }"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "namespace b{ void f(){} }"; const std::string expected("void f ( ) { }"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "int a; namespace b{ }"; const std::string expected("int a ;"); ASSERT_EQUALS(expected, sizeof_(code)); } { const char code[] = "void f(int namespace) { }"; const std::string expected("void f ( int namespace ) { }"); ASSERT_EQUALS(expected, sizeof_(code)); } } std::string simplifyIfAssign(const char code[]) { // tokenize.. Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); tokenizer.simplifyIfAssign(); std::ostringstream ostr; for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) ostr << (tok->previous() ? " " : "") << tok->str(); return ostr.str(); } void ifassign1() { ASSERT_EQUALS("; a = b ; if ( a ) { ; }", simplifyIfAssign(";if(a=b);")); ASSERT_EQUALS("; a = b ( ) ; if ( a ) { ; }", simplifyIfAssign(";if((a=b()));")); ASSERT_EQUALS("; a = b ( ) ; if ( ! ( a ) ) { ; }", simplifyIfAssign(";if(!(a=b()));")); ASSERT_EQUALS("; a . x = b ( ) ; if ( ! ( a . x ) ) { ; }", simplifyIfAssign(";if(!(a->x=b()));")); ASSERT_EQUALS("A ( ) a = b ; if ( a ) { ; }", simplifyIfAssign("A() if(a=b);")); ASSERT_EQUALS("void foo ( int a ) { a = b ( ) ; if ( 0 <= a ) { ; } }", tok("void foo(int a) {if((a=b())>=0);}")); TODO_ASSERT_EQUALS("void foo ( A a ) { a . c = b ( ) ; if ( 0 <= a . c ) { ; } }", tok("void foo(A a) {if((a.c=b())>=0);}")); } void whileAssign() { ASSERT_EQUALS("; a = b ; while ( a ) { b = 0 ; a = b ; }", simplifyIfAssign(";while(a=b) { b = 0; }")); ASSERT_EQUALS("; a . b = c ; while ( a . b ) { c = 0 ; a . b = c ; }", simplifyIfAssign(";while(a.b=c) { c=0; }")); ASSERT_EQUALS("struct hfs_bnode * node ; " "struct hfs_btree * tree ; " "node = tree . node_hash [ i ++ ] ; " "while ( node ) { node = tree . node_hash [ i ++ ] ; }", tok("struct hfs_bnode *node;" "struct hfs_btree *tree;" "while ((node = tree->node_hash[i++])) { }")); } std::string simplifyIfNot(const char code[]) { // tokenize.. Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); tokenizer.simplifyIfNot(); std::ostringstream ostr; for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) ostr << (tok->previous() ? " " : "") << tok->str(); return ostr.str(); } void ifnot() { ASSERT_EQUALS("if ( ! x )", simplifyIfNot("if(0==x)")); ASSERT_EQUALS("if ( ! x )", simplifyIfNot("if(x==0)")); ASSERT_EQUALS("if ( ! ( a = b ) )", simplifyIfNot("if(0==(a=b))")); ASSERT_EQUALS("if ( ! x )", simplifyIfNot("if(x==0)")); ASSERT_EQUALS("if ( ! a && b ( ) )", simplifyIfNot("if( 0 == a && b() )")); ASSERT_EQUALS("if ( b ( ) && ! a )", simplifyIfNot("if( b() && 0 == a )")); ASSERT_EQUALS("if ( ! ( a = b ) )", simplifyIfNot("if((a=b)==0)")); ASSERT_EQUALS("if ( ! x . y )", simplifyIfNot("if(x.y==0)")); ASSERT_EQUALS("if ( ! x )", simplifyIfNot("if((x==0))")); ASSERT_EQUALS("if ( ( ! x ) && ! y )", simplifyIfNot("if((x==0) && y==0)")); ASSERT_EQUALS("if ( ! ( ! fclose ( fd ) ) )", simplifyIfNot("if(!(fclose(fd) == 0))")); } std::string simplifyLogicalOperators(const char code[]) { // tokenize.. Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); tokenizer.simplifyLogicalOperators(); std::ostringstream ostr; for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) ostr << (tok->previous() ? " " : "") << tok->str(); return ostr.str(); } void not1() { ASSERT_EQUALS("if ( ! p )", simplifyLogicalOperators("if (not p)")); ASSERT_EQUALS("if ( p && ! q )", simplifyLogicalOperators("if (p && not q)")); ASSERT_EQUALS("void foo ( not i )", simplifyLogicalOperators("void foo ( not i )")); } void and1() { ASSERT_EQUALS("if ( p && q ) { ; }", simplifyLogicalOperators("if (p and q) ;")); ASSERT_EQUALS("if ( foo ( ) && q ) { ; }", simplifyLogicalOperators("if (foo() and q) ;")); ASSERT_EQUALS("if ( foo ( ) && bar ( ) ) { ; }", simplifyLogicalOperators("if (foo() and bar()) ;")); ASSERT_EQUALS("if ( p && bar ( ) ) { ; }", simplifyLogicalOperators("if (p and bar()) ;")); } void comma_keyword() { { const char code[] = "void foo()\n" "{\n" " char *a, *b;\n" " delete a, delete b;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a ; delete b ; }", sizeof_(code)); } { const char code[] = "void foo()\n" "{\n" " struct A *a, *b;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { struct A * a ; struct A * b ; }", sizeof_(code)); } { const char code[] = "void foo()\n" "{\n" " struct A **a, **b;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { struct A * * a ; struct A * * b ; }", sizeof_(code)); } { const char code[] = "void foo()\n" "{\n" " char *a, *b;\n" " delete a, b;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a ; delete b ; }", sizeof_(code)); } { const char code[] = "void foo()\n" "{\n" " char **a, **b, **c;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { char * * a ; char * * b ; char * * c ; }", sizeof_(code)); } { const char code[] = "int f()\n" "{\n" " if (something)\n" " return a(2, c(3, 4)), b(3), 10;\n" " return a(), b(0, 0, 0), 10;\n" "}\n"; ASSERT_EQUALS("int f ( )" " {" " if ( something )" " {" " a ( 2 , c ( 3 , 4 ) ) ;" " b ( 3 ) ;" " return 10 ;" " }" " a ( ) ;" " b ( 0 , 0 , 0 ) ;" " return 10 ; " "}", sizeof_(code)); } { const char code[] = "void foo()\n" "{\n" " delete [] a, a = 0;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { delete [ ] a ; a = 0 ; }", sizeof_(code)); } { const char code[] = "void foo()\n" "{\n" " delete a, a = 0;\n" "}\n"; ASSERT_EQUALS("void foo ( ) { delete a ; a = 0 ; }", sizeof_(code)); } { const char code[] = "void f()\n" "{\n" " for(int a,b; a < 10; a = a + 1, b = b + 1);\n" "}\n"; ASSERT_EQUALS("void f ( ) { for ( int a , b ; a < 10 ; a = a + 1 , b = b + 1 ) { ; } }", sizeof_(code)); } { const char code[] = "void f()\n" "{\n" " char buf[BUFSIZ], **p;\n" " char *ptrs[BUFSIZ], **pp;\n" "}\n"; ASSERT_EQUALS("void f ( ) { char buf [ BUFSIZ ] ; char * * p ; char * ptrs [ BUFSIZ ] ; char * * pp ; }", sizeof_(code)); } } void remove_comma() { { const char code[] = "void f()\n" "{\n" " int a,b;\n" " if( a )\n" " a=0,\n" " b=0;\n" "}\n"; ASSERT_EQUALS("void f ( ) { int a ; int b ; if ( a ) { a = 0 ; b = 0 ; } }", sizeof_(code)); } { const char code[] = "void f()\n" "{\n" " A a,b;\n" " if( a.f )\n" " a.f=b.f,\n" " a.g=b.g;\n" "}\n"; ASSERT_EQUALS("void f ( ) { A a ; A b ; if ( a . f ) { a . f = b . f ; a . g = b . g ; } }", sizeof_(code)); } // keep the comma in template specifiers.. { const char code[] = "void f()\n" "{\n" " int a = b, int>();\n" "}\n"; ASSERT_EQUALS("void f ( ) { int a ; a = b < T < char , 3 > , int > ( ) ; }", sizeof_(code)); } { // ticket #1327 const char code[] = "const C<1,2,3> foo ()\n" "{\n" " return C<1,2,3>(x,y);\n" "}\n"; const char expected[] = "const C < 1 , 2 , 3 > foo ( ) " "{" " return C < 1 , 2 , 3 > ( x , y ) ; " "}"; ASSERT_EQUALS(expected, sizeof_(code)); } } void conditionOperator() { { const char code[] = "; x = a ? b : c;"; ASSERT_EQUALS("; if ( a ) { x = b ; } else { x = c ; }", tok(code)); } { const char code[] = "(0?(false?1:2):3)"; ASSERT_EQUALS("( 3 )", tok(code)); } { const char code[] = "(1?(false?1:2):3)"; ASSERT_EQUALS("( 2 )", tok(code)); } { const char code[] = "int a = (1?0:1 == 1?0:1);"; ASSERT_EQUALS("int a ; a = 0 ;", tok(code)); } { const char code[] = "(1?0:foo())"; ASSERT_EQUALS("( 0 )", tok(code)); } { const char code[] = "( true ? a ( ) : b ( ) )"; ASSERT_EQUALS("( a ( ) )", tok(code)); } { const char code[] = "( true ? abc . a : abc . b )"; ASSERT_EQUALS("( abc . a )", tok(code)); } { const char code[] = "void f()\n" "{\n" " bool x = false;\n" " int b = x ? 44 : 3;\n" "}\n"; ASSERT_EQUALS("void f ( ) { ; ; int b ; b = 3 ; }", tok(code)); } { const char code[] = "int vals[] = { 0x13, 1?0x01:0x00 };"; ASSERT_EQUALS("int * vals ; vals = { 19 , 1 } ;", tok(code)); } { const char code[] = "int vals[] = { 0x13, 0?0x01:0x00 };"; ASSERT_EQUALS("int * vals ; vals = { 19 , 0 } ;", tok(code)); } } void calculations() { { const char code[] = "a[i+8+2]"; ASSERT_EQUALS("a [ i + 10 ]", tok(code)); } { const char code[] = "a[8+2+i]"; ASSERT_EQUALS("a [ 10 + i ]", tok(code)); } { const char code[] = "a[i + 2 * (2 * 4)]"; ASSERT_EQUALS("a [ i + 16 ]", tok(code)); } { const char code[] = "a[i + 100 - 90]"; ASSERT_EQUALS("a [ i + 10 ]", tok(code)); } { const char code[] = "a[1+1+1+1+1+1+1+1+1+1-2+5-3]"; ASSERT_EQUALS("a [ 10 ]", tok(code)); } { const char code[] = "a[10+10-10-10]"; ASSERT_EQUALS("a [ 0 ]", tok(code)); } ASSERT_EQUALS("x = 1 + 2 * y ;", tok("x=1+2*y;")); ASSERT_EQUALS("x = 7 ;", tok("x=1+2*3;")); ASSERT_EQUALS("x = 47185 ;", tok("x=(65536*72/100);")); ASSERT_EQUALS("x = 900 ;", tok("x = 1500000 / ((145000 - 55000) * 1000 / 54000);")); ASSERT_EQUALS("int a [ 8 ] ;", tok("int a[5+6/2];")); ASSERT_EQUALS("int a [ 4 ] ;", tok("int a[(10)-1-5];")); ASSERT_EQUALS("int a [ i - 9 ] ;", tok("int a[i - 10 + 1];")); } void goto1() { { const char code[] = "void foo()\n" "{\n" " if (a())\n" " {\n" " goto out;\n" " }\n" " b();\n" "out:\n" " c();\n" "}"; std::istringstream istr(code); Tokenizer tokenizer; tokenizer.tokenize(istr, "test.cpp"); tokenizer.simplifyTokenList(); tokenizer.validate(); const char expect[] = "\n\n##file 0\n" "1: void foo ( )\n" "2: {\n" "3: if ( a ( ) )\n" "4: {\n" "5:\n6:\n7:\n8:\n" "9: c ( ) ; return ; }\n" "7: b ( ) ;\n" "8:\n" "9: c ( ) ;\n" "10: }\n"; ASSERT_EQUALS(expect, tokenizer.tokens()->stringifyList("")); } { const char code[] = "void foo()\n" "{\n" " if (a())\n" " goto out;\n" " b();\n" "out:\n" " if (c())\n" " d();\n" "}"; std::istringstream istr(code); Tokenizer tokenizer; tokenizer.tokenize(istr, "test.cpp"); tokenizer.simplifyTokenList(); tokenizer.validate(); const char expect[] = "\n\n##file 0\n" "1: void foo ( )\n" "2: {\n" "3: if ( a ( ) ) {\n" "4:\n5:\n6:\n" "7: if ( c ( ) ) {\n" "8: d ( ) ; } return ; }\n" "5: b ( ) ;\n" "6:\n" "7: if ( c ( ) ) {\n" "8: d ( ) ; }\n" "9: }\n"; ASSERT_EQUALS(expect, tokenizer.tokens()->stringifyList("")); } { const char code[] = "void foo()\n" "{\n" " if (a())\n" " goto out;\n" " b();\n" "out:\n" " if (c())\n" " {\n" " d();\n" " }\n" "}"; const char expect[] = "void foo ( ) " "{ " "if ( a ( ) ) " "{ " "if ( c ( ) ) " "{ d ( ) ; } " "return ; " "} " "b ( ) ; " "if ( c ( ) ) " "{ d ( ) ; } " "}"; ASSERT_EQUALS(expect, tok(code)); } { const char code[] = "void foo(int x)\n" "{\n" " if (a())\n" " goto out;\n" " b();\n" "out:\n" " if (x)\n" " {\n" " x++; b[0]=x;\n" " }\n" "}"; const char expect[] = "void foo ( int x ) " "{ " "if ( a ( ) ) " "{ " "if ( x ) " "{ x ++ ; b [ 0 ] = x ; } " "return ; " "} " "b ( ) ; " "if ( x ) " "{ x ++ ; b [ 0 ] = x ; } " "}"; ASSERT_EQUALS(expect, tok(code)); } { const char code[] = "class NoLabels { bool varOne : 1 ; bool varTwo : 1 ; } ;"; ASSERT_EQUALS(code, tok(code)); } { const char code[] = "void foo ( ) { int var ; var = x < y ? y : z ; } ;"; ASSERT_EQUALS(code, tok(code)); } } void strcat1() { const char code[] = "; strcat(strcat(strcat(strcat(strcat(strcat(dst, \"this \"), \"\"), \"is \"), \"a \"), \"test\"), \".\");"; const char expect[] = "; " "strcat ( dst , \"this \" ) ; " "strcat ( dst , \"\" ) ; " "strcat ( dst , \"is \" ) ; " "strcat ( dst , \"a \" ) ; " "strcat ( dst , \"test\" ) ; " "strcat ( dst , \".\" ) ;"; ASSERT_EQUALS(expect, tok(code)); } void strcat2() { const char code[] = "; strcat(strcat(dst, foo[0]), \" \");"; const char expect[] = "; " "strcat ( dst , foo [ 0 ] ) ; " "strcat ( dst , \" \" ) ;"; ASSERT_EQUALS(expect, tok(code)); } void argumentsWithSameName() { // This code has syntax error, two variables can not have the same name { const char code[] = "void foo(x, x)\n" " int x;\n" " int x;\n" "{}\n"; ASSERT_EQUALS("void foo ( x , x ) int x ; int x ; { }", tok(code)); } { const char code[] = "void foo(x, y)\n" " int x;\n" " int x;\n" "{}\n"; ASSERT_EQUALS("void foo ( int x , y ) int x ; { }", tok(code)); } } void simplifyAtol() { ASSERT_EQUALS("a = std :: atol ( x ) ;", tok("a = std::atol(x);")); ASSERT_EQUALS("a = atol ( \"text\" ) ;", tok("a = atol(\"text\");")); ASSERT_EQUALS("a = 0 ;", tok("a = std::atol(\"0\");")); ASSERT_EQUALS("a = 10 ;", tok("a = atol(\"0xa\");")); } void simplifyHexInString() { ASSERT_EQUALS("\"a\"", tok("\"\\x61\"")); ASSERT_EQUALS("\"a\"", tok("\"\\141\"")); ASSERT_EQUALS("\"\\0\"", tok("\"\\x00\"")); ASSERT_EQUALS("\"\\0\"", tok("\"\\000\"")); ASSERT_EQUALS("\"\\nhello\"", tok("\"\\nhello\"")); ASSERT_EQUALS("\"aaa\"", tok("\"\\x61\\x61\\x61\"")); ASSERT_EQUALS("\"aaa\"", tok("\"\\141\\141\\141\"")); ASSERT_EQUALS("\"\\\\x61\"", tok("\"\\\\x61\"")); // These tests can fail, if other characters are handled // more correctly. But fow now all non null characters should // become 'a' ASSERT_EQUALS("\"a\"", tok("\"\\x62\"")); ASSERT_EQUALS("\"a\"", tok("\"\\177\"")); } std::string simplifyTypedef(const char code[]) { errout.str(""); Settings settings; Tokenizer tokenizer(&settings, this); tokenizer._files.push_back("test.cpp"); std::istringstream istr(code); tokenizer.createTokens(istr); tokenizer.createLinks(); tokenizer.simplifyTypedef(); std::string ret; for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) { if (tok != tokenizer.tokens()) ret += " "; ret += tok->str(); } return ret; } void simplifyTypedef1() { const char code[] = "class A\n" "{\n" "public:\n" " typedef wchar_t duplicate;\n" " void foo() {}\n" "};\n" "typedef A duplicate;\n" "int main()\n" "{\n" " duplicate a;\n" " a.foo();\n" " A::duplicate c = 0;\n" "}\n"; const std::string expected = "class A " "{ " "public: " "; " "void foo ( ) { } " "} ; " "; " "int main ( ) " "{ " "A a ; " "a . foo ( ) ; " "wchar_t c ; c = 0 ; " "}"; ASSERT_EQUALS(expected, tok(code)); } void simplifyTypedef2() { const char code[] = "class A;\n" "typedef A duplicate;\n" "class A\n" "{\n" "public:\n" "typedef wchar_t duplicate;\n" "duplicate foo() { wchar_t b; return b; }\n" "};\n"; const std::string expected = "class A ; " "; " "class A " "{ " "public: " "; " "wchar_t foo ( ) { wchar_t b ; return b ; } " "} ;"; ASSERT_EQUALS(expected, tok(code)); } void simplifyTypedef3() { const char code[] = "class A {};\n" "typedef A duplicate;\n" "wchar_t foo()\n" "{\n" "typedef wchar_t duplicate;\n" "duplicate b;\n" "return b;\n" "}\n" "int main()\n" "{\n" "duplicate b;\n" "}\n"; const std::string expected = "class A { } ; " "; " "wchar_t foo ( ) " "{ " "; " "wchar_t b ; " "return b ; " "} " "int main ( ) " "{ " "A b ; " "}"; ASSERT_EQUALS(expected, tok(code)); } void simplifyTypedef4() { const char code[] = "typedef int s32;\n" "typedef unsigned int u32;\n" "void f()\n" "{\n" " s32 ivar = -2;\n" " u32 uvar = 2;\n" " return uvar / ivar;\n" "}\n"; const std::string expected = "; " "; " "void f ( ) " "{ " "int ivar ; ivar = -2 ; " "unsigned int uvar ; uvar = 2 ; " "return uvar / ivar ; " "}"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef5() { // ticket #780 const char code[] = "typedef struct yy_buffer_state *YY_BUFFER_STATE;\n" "void f()\n" "{\n" " YY_BUFFER_STATE state;\n" "}\n"; const char expected[] = "; " "void f ( ) " "{ " "struct yy_buffer_state * state ; " "}"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef6() { // ticket #983 const char code[] = "namespace VL {\n" " typedef float float_t ;\n" " inline VL::float_t fast_atan2(VL::float_t y, VL::float_t x){}\n" "}\n"; const char expected[] = "namespace VL { " "; " "float fast_atan2 ( float y , float x ) { } " "}"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef7() { const char code[] = "typedef int abc ; " "Fred :: abc f ;"; const char expected[] = "; " "Fred :: abc f ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef8() { const char code[] = "typedef int INT;\n" "typedef unsigned int UINT;\n" "typedef int * PINT;\n" "typedef unsigned int * PUINT;\n" "typedef int & RINT;\n" "typedef unsigned int & RUINT;\n" "typedef const int & RCINT;\n" "typedef const unsigned int & RCUINT;\n" "INT ti;\n" "UINT tui;\n" "PINT tpi;\n" "PUINT tpui;\n" "RINT tri;\n" "RUINT trui;\n" "RCINT trci;\n" "RCUINT trcui;"; const char expected[] = "; " "; " "; " "; " "; " "; " "; " "; " "int ti ; " "unsigned int tui ; " "int * tpi ; " "unsigned int * tpui ; " "int & tri ; " "unsigned int & trui ; " "const int & trci ; " "const unsigned int & trcui ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef9() { const char code[] = "typedef struct s S, * PS;\n" "typedef struct t { int a; } T, *TP;\n" "typedef struct { int a; } U;\n" "typedef struct { int a; } * V;\n" "S s;\n" "PS ps;\n" "T t;\n" "TP tp;\n" "U u;\n" "V v;"; const char expected[] = "; " "struct t { int a ; } ; ; " "struct U { int a ; } ; ; " "struct Unnamed0 { int a ; } ; ; " "struct s s ; " "struct s * ps ; " "struct t t ; " "struct t * tp ; " "struct U u ; " "struct Unnamed0 * v ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef10() { const char code[] = "typedef union s S, * PS;\n" "typedef union t { int a; float b ; } T, *TP;\n" "typedef union { int a; float b; } U;\n" "typedef union { int a; float b; } * V;\n" "S s;\n" "PS ps;\n" "T t;\n" "TP tp;\n" "U u;\n" "V v;"; const char expected[] = "; " "union t { int a ; float b ; } ; ; " "union U { int a ; float b ; } ; ; " "union Unnamed1 { int a ; float b ; } ; ; " "union s s ; " "union s * ps ; " "union t t ; " "union t * tp ; " "union U u ; " "union Unnamed1 * v ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef11() { const char code[] = "typedef enum { a = 0 , b = 1 , c = 2 } abc;\n" "typedef enum xyz { x = 0 , y = 1 , z = 2 } XYZ;\n" "abc e1;\n" "XYZ e2;"; const char expected[] = "; ; " "; ; " "int e1 ; " "int e2 ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef12() { const char code[] = "typedef vector V1;\n" "typedef std::vector V2;\n" "typedef std::vector > V3;\n" "typedef std::list::iterator IntListIterator;\n" "V1 v1;\n" "V2 v2;\n" "V3 v3;\n" "IntListIterator iter;"; const char expected[] = "; " "; " "; " "; " "vector < int > v1 ; " "std :: vector < int > v2 ; " "std :: vector < std :: vector < int > > v3 ; " "std :: list < int > :: iterator iter ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef13() { // ticket # 1167 const char code[] = "typedef std::pair Func;" "typedef std::vector CallQueue;" "int main() {}"; Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); // Clear the error buffer.. errout.str(""); tokenizer.simplifyTokenList(); ASSERT_EQUALS("", errout.str()); } void simplifyTypedef14() { // ticket # 1232 const char code[] = "template struct E" "{" " typedef E0)?(N-1):0> v;" " typedef typename add::val val;" " FP_M(val);" "};" "template struct E " "{" " typedef typename D<1>::val val;" " FP_M(val);" "};"; Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); // Clear the error buffer.. errout.str(""); tokenizer.simplifyTokenList(); ASSERT_EQUALS("", errout.str()); } void simplifyTypedef15() { { const char code[] = "typedef char frame[10];\n" "frame f;"; const char expected[] = "; " "char f [ 10 ] ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "typedef unsigned char frame[10];\n" "frame f;"; const char expected[] = "; " "unsigned char f [ 10 ] ;"; ASSERT_EQUALS(expected, tok(code, false)); } } void simplifyTypedef16() { // ticket # 1252 const char code[] = "typedef char MOT8;\n" "typedef MOT8 CHFOO[4096];\n" "typedef struct {\n" " CHFOO freem;\n" "} STRFOO;"; Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); // Clear the error buffer.. errout.str(""); tokenizer.simplifyTokenList(); ASSERT_EQUALS("", errout.str()); } void simplifyTypedef17() { const char code[] = "typedef char * PCHAR, CHAR;\n" "PCHAR pc;\n" "CHAR c;"; const char expected[] = "; " "char * pc ; " "char c ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef18() { const char code[] = "typedef vector a;\n" "a b;\n"; Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); // Clear the error buffer.. errout.str(""); tokenizer.simplifyTokenList(); ASSERT_EQUALS(true, tokenizer.validate()); } void simplifyTypedef19() { { // ticket #1275 const char code[] = "typedef struct {} A, *B, **C;\n" "A a;\n" "B b;\n" "C c;"; const char expected[] = "struct A { } ; ; " "struct A a ; " "struct A * b ; " "struct A * * c ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "typedef struct {} A, *********B;\n" "A a;\n" "B b;"; const char expected[] = "struct A { } ; ; " "struct A a ; " "struct A * * * * * * * * * b ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "typedef struct {} **********A, *B, C;\n" "A a;\n" "B b;\n" "C c;"; const char expected[] = "struct Unnamed2 { } ; ; " "struct Unnamed2 * * * * * * * * * * a ; " "struct Unnamed2 * b ; " "struct Unnamed2 c ;"; ASSERT_EQUALS(expected, tok(code, false)); } } void simplifyTypedef20() { // ticket #1284 const char code[] = "typedef jobject invoke_t (jobject, Proxy *, Method *, JArray< jobject > *);"; Tokenizer tokenizer; std::istringstream istr(code); tokenizer.tokenize(istr, "test.cpp"); // Clear the error buffer.. errout.str(""); tokenizer.simplifyTokenList(); ASSERT_EQUALS(true, tokenizer.validate()); } void simplifyTypedef21() { const char code[] = "typedef void (* PF)();\n" "typedef void * (* PFV)(void *);\n" "PF pf;\n" "PFV pfv;"; const char expected[] = "; " "; " "void ( * pf ) ( ) ; " "void * ( * pfv ) ( void * ) ;"; ASSERT_EQUALS(expected, simplifyTypedef(code)); } void simplifyTypedef22() { { const char code[] = "class Fred {\n" " typedef void (*testfp)();\n" " testfp get() { return test; }\n" " static void test() { }\n" "};"; const char expected[] = "class Fred { " "; " "void ( * get ( ) ) ( ) { return test ; } " "static void test ( ) { } " "} ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "class Fred {\n" " typedef void * (*testfp)(void *);\n" " testfp get() { return test; }\n" " static void * test(void * p) { return p; }\n" "};\n"; const char expected[] = "class Fred { " "; " "void * ( * get ( ) ) ( void * ) { return test ; } " "static void * test ( void * p ) { return p ; } " "} ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "class Fred {\n" " typedef unsigned int * (*testfp)(unsigned int *);\n" " testfp get() { return test; }\n" " static unsigned int * test(unsigned int * p) { return p; }\n" "};\n"; const char expected[] = "class Fred { " "; " "unsigned int * ( * get ( ) ) ( unsigned int * ) { return test ; } " "static unsigned int * test ( unsigned int * p ) { return p ; } " "} ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "class Fred {\n" " typedef const unsigned int * (*testfp)(const unsigned int *);\n" " testfp get() { return test; }\n" " static const unsigned int * test(const unsigned int * p) { return p; }\n" "};\n"; // static const gets changed to const static const char expected[] = "class Fred { " "; " "const unsigned int * ( * get ( ) ) ( const unsigned int * ) { return test ; } " "const static unsigned int * test ( const unsigned int * p ) { return p ; } " "} ;"; ASSERT_EQUALS(expected, tok(code, false)); } { const char code[] = "class Fred {\n" " typedef void * (*testfp)(void *);\n" " testfp get(int i) { return test; }\n" " static void * test(void * p) { return p; }\n" "};\n"; const char expected[] = "class Fred { " "; " "void * ( * get ( int i ) ) ( void * ) { return test ; } " "static void * test ( void * p ) { return p ; } " "} ;"; ASSERT_EQUALS(expected, tok(code, false)); } } void simplifyTypedef23() { const char code[] = "typedef bool (*Callback) (int i);\n" "void addCallback(Callback callback) { }\n" "void addCallback1(Callback callback, int j) { }"; const char expected[] = "; " "void addCallback ( bool ( * callback ) ( int i ) ) { } " "void addCallback1 ( bool ( * callback ) ( int i ) , int j ) { }"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef24() { { const char code[] = "typedef int (*fp)();\n" "void g( fp f )\n" "{\n" " fp f2 = (fp)f;\n" "}"; const char expected[] = "; " "void g ( int ( * f ) ( ) ) " "{ " "int ( * f2 ) ( ) = ( int ( * ) ( ) ) f ; " "}"; ASSERT_EQUALS(expected, tok(code, false)); // TODO: the definition and assignment should be split up const char todo[] = "; " "void g ( fp f ) " "{ " "int ( * f2 ) ( ) ; f2 = ( int ( * ) ( ) ) f ; " "}"; TODO_ASSERT_EQUALS(todo, tok(code, false)); } { const char code[] = "typedef int (*fp)();\n" "void g( fp f )\n" "{\n" " fp f2 = static_cast(f);\n" "}"; const char expected[] = "; " "void g ( int ( * f ) ( ) ) " "{ " "int ( * f2 ) ( ) = static_cast < int ( * ) ( ) > ( f ) ; " "}"; ASSERT_EQUALS(expected, tok(code, false)); } } void simplifyTypedef25() { { // ticket #1298 const char code[] = "typedef void (*fill_names_f) (const char *);\n" "struct vfs_class {\n" " void (*fill_names) (struct vfs_class *me, fill_names_f);\n" "}"; const char expected[] = "; " "struct vfs_class { " "void ( * fill_names ) ( struct vfs_class * me , void ( * ) ( const char * ) ) ; " "}"; ASSERT_EQUALS(expected, simplifyTypedef(code)); } { const char code[] = "typedef void (*fill_names_f) (const char *);\n" "struct vfs_class {\n" " void (*fill_names) (fill_names_f, struct vfs_class *me);\n" "}"; const char expected[] = "; " "struct vfs_class { " "void ( * fill_names ) ( void ( * ) ( const char * ) , struct vfs_class * me ) ; " "}"; ASSERT_EQUALS(expected, simplifyTypedef(code)); } } void simplifyTypedef26() { { const char code[] = "typedef void (*Callback) ();\n" "void addCallback(Callback (*callback)());"; const char expected[] = "; " "void addCallback ( void ( * ( * callback ) ( ) ) ( ) ) ;"; ASSERT_EQUALS(expected, tok(code, false)); } { // ticket # 1307 const char code[] = "typedef void (*pc_video_update_proc)(bitmap_t *bitmap,\n" "struct mscrtc6845 *crtc);\n" "\n" "struct mscrtc6845 *pc_video_start(pc_video_update_proc (*choosevideomode)(running_machine *machine, int *width, int *height, struct mscrtc6845 *crtc));"; const char expected[] = "; " "struct mscrtc6845 * pc_video_start ( void ( * ( * choosevideomode ) ( running_machine * machine , int * width , int * height , struct mscrtc6845 * crtc ) ) ( bitmap_t * bitmap , struct mscrtc6845 * crtc ) ) ;"; ASSERT_EQUALS(expected, tok(code, false)); } } void simplifyTypedef27() { // ticket #1316 const char code[] = "int main()\n" "{\n" " typedef int (*func_ptr)(float, double);\n" " VERIFY((is_same::type, int>::value));\n" "}"; const char expected[] = "int main ( ) " "{ " "; " "VERIFY ( is_same < result_of < int ( * ( char , float ) ) ( float , double ) > :: type , int > :: value ) ; " "}"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef28() { const char code[] = "typedef std::pair (*F)(double);\n" "F f;"; const char expected[] = "; " "std :: pair < double , double > ( * f ) ( double ) ;"; ASSERT_EQUALS(expected, tok(code, false)); } void simplifyTypedef29() { const char code[] = "typedef int array [ice_or::value, is_int::value>::value ? 1 : -1];\n" "typedef int array1 [N];\n" "typedef int array2 [N][M];\n" "typedef int int_t, int_array[N];\n" "array a;\n" "array1 a1;\n" "array2 a2;\n" "int_t t;\n" "int_array ia;"; const char expected[] = "; " "; " "; " "; " "int a [ ice_or < is_int < int > :: value , is_int < UDT > :: value > :: value ? 1 : - 1 ] ; " "int a1 [ N ] ; " "int a2 [ N ] [ M ] ; " "int t ; " "int ia [ N ] ;"; ASSERT_EQUALS(expected, tok(code, false)); } void reverseArraySyntax() { ASSERT_EQUALS("a [ 13 ]", tok("13[a]")); } void simplify_numeric_condition() { { const char code[] = "void f()\n" "{\n" "int x = 0;\n" "if( !x || 0 )\n" "{ g();\n" "}\n" "}"; ASSERT_EQUALS("void f ( ) { int x ; x = 0 ; { g ( ) ; } }", tok(code)); } { const char code[] = "void f()\n" "{\n" "int x = 1;\n" "if( !x )\n" "{ g();\n" "}\n" "}"; ASSERT_EQUALS("void f ( ) { int x ; x = 1 ; }", tok(code)); } { const char code[] = "void f()\n" "{\n" "bool x = true;\n" "if( !x )\n" "{ g();\n" "}\n" "}"; ASSERT_EQUALS("void f ( ) { ; ; }", tok(code)); } { const char code[] = "void f()\n" "{\n" "bool x = false;\n" "if( !x )\n" "{ g();\n" "}\n" "}"; ASSERT_EQUALS("void f ( ) { ; ; { g ( ) ; } }", tok(code)); } { const char code[] = "void f()\n" "{\n" " if (5==5);\n" "}\n"; ASSERT_EQUALS("void f ( ) { { ; } }", tok(code)); } { const char code[] = "void f()\n" "{\n" " if (4<5);\n" "}\n"; ASSERT_EQUALS("void f ( ) { { ; } }", tok(code)); } { const char code[] = "void f()\n" "{\n" " if (5<5);\n" "}\n"; ASSERT_EQUALS("void f ( ) { }", tok(code)); } { const char code[] = "void f()\n" "{\n" " if (13>12?true:false);\n" "}\n"; ASSERT_EQUALS("void f ( ) { { ; } }", tok(code)); } } void pointeralias() { { const char code[] = "void f()\n" "{\n" " char buf[100];\n" " char *p = buf;\n" " x(p);\n" "}\n"; const char expected[] = "void f ( ) " "{ " "char buf [ 100 ] ; " "; ; " "x ( buf ) ; " "}"; ASSERT_EQUALS(expected, tok(code)); } { const char code[] = "void f(char *p1)\n" "{\n" " char *p = p1;\n" " p1 = 0;" " x(p);\n" "}\n"; const char expected[] = "void f ( char * p1 ) " "{ " "char * p ; p = p1 ; " "p1 = 0 ; " "x ( p ) ; " "}"; ASSERT_EQUALS(expected, tok(code)); } { const char code[] = "void foo(Result* ptr)\n" "{\n" " Result* obj = ptr;\n" " ++obj->total;\n" "}\n"; const char expected[] = "void foo ( Result * ptr ) " "{ " "Result * obj ; obj = ptr ; " "++ obj . total ; " "}"; ASSERT_EQUALS(expected, tok(code)); } { const char code[] = "int *foo()\n" "{\n" " int a[10];\n" " int *b = a;\n" " return b;\n" "}\n"; const char expected[] = "int * foo ( ) " "{ " "int a [ 10 ] ; " "; ; " "return a ; " "}"; ASSERT_EQUALS(expected, tok(code)); } { const char code[] = "int a[10];\n" "int *b = a;\n" "memset(b,0,sizeof(a));"; const char expected[] = "int a [ 10 ] ; " "int * b ; b = a ; " "memset ( a , 0 , 40 ) ;"; TODO_ASSERT_EQUALS(expected, tok(code)); } } void reduceConstness() { ASSERT_EQUALS("char * p ;", tok("char * const p;")); } void while0() { ASSERT_EQUALS("; x = 1 ; ;", tok("; do { x = 1 ; } while (0);")); ASSERT_EQUALS("; do { continue ; } while ( false ) ;", tok("; do { continue ; } while (0);")); ASSERT_EQUALS("; do { break ; } while ( false ) ;", tok("; do { break; } while (0);")); } void while1() { // ticket #1197 const char code[] = "void do {} while (0) { }"; const char expected[] = "void { }"; ASSERT_EQUALS(expected, tok(code)); } void enum1() { const char code[] = "enum A { a, b, c }; A c1 = c;"; const char expected[] = "; int c1 ; c1 = 2 ;"; ASSERT_EQUALS(expected, tok(code, false)); } void enum2() { const char code[] = "enum A { a, }; int array[a];"; const char expected[] = "; int array [ 0 ] ;"; ASSERT_EQUALS(expected, tok(code, false)); } void enum3() { const char code[] = "enum { a, }; int array[a];"; const char expected[] = "; int array [ 0 ] ;"; ASSERT_EQUALS(expected, tok(code, false)); } void enum4() { const char code[] = "class A {\n" "public:\n" " enum EA { a1, a2, a3 };\n" " EA get() const;\n" " void put(EA a) { ea = a; ea = a1; }\n" "private:\n" " EA ea;\n" "};\n" "A::EA A::get() const { return ea; }\n" "A::EA e = A::a1;"; const char expected[] = "class A { " "public: " "; " "int get ( ) const ; " "void put ( int a ) { ea = a ; ea = 0 ; } " "private: " "int ea ; " "} ; " "int A :: get ( ) const { return ea ; } " "int e ; e = 0 ;"; ASSERT_EQUALS(expected, tok(code, false)); } void removestd() { ASSERT_EQUALS("; strcpy ( a , b ) ;", tok("; std::strcpy(a,b);")); ASSERT_EQUALS("; strcat ( a , b ) ;", tok("; std::strcat(a,b);")); ASSERT_EQUALS("; strncpy ( a , b , 10 ) ;", tok("; std::strncpy(a,b,10);")); ASSERT_EQUALS("; strncat ( a , b , 10 ) ;", tok("; std::strncat(a,b,10);")); ASSERT_EQUALS("; free ( p ) ;", tok("; std::free(p);")); ASSERT_EQUALS("; malloc ( 10 ) ;", tok("; std::malloc(10);")); } void simplifyInitVar() { // ticket #1005 - int *p(0); => int *p = 0; { const char code[] = "void foo() { int *p(0); }"; ASSERT_EQUALS("void foo ( ) { int * p ; p = 0 ; }", tok(code)); } { const char code[] = "void foo() { int p(0); }"; ASSERT_EQUALS("void foo ( ) { int p ; p = 0 ; }", tok(code)); } { const char code[] = "void a() { foo *p(0); }"; ASSERT_EQUALS("void a ( ) { foo * p ; p = 0 ; }", tok(code)); } } }; REGISTER_TEST(TestSimplifyTokens)