TestPreprocessor()

: TestFixture("TestPreprocessor")

, preprocessor0(settings0, this) {

}

class OurPreprocessor : public Preprocessor {

public:

static std::string expandMacros(const char code[], ErrorLogger *errorLogger = 0) {

std::istringstream istr(code);

simplecpp::OutputList outputList;

std::vector<std::string> files;

const simplecpp::TokenList tokens1 = simplecpp::TokenList(istr, files, "file.cpp", &outputList);

const std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI(), &outputList);

if (errorLogger) {

Settings settings;

Preprocessor p(settings, errorLogger);

p.reportOutput(outputList, true);

}

return tokens2.stringify();

}

};

Settings settings0;

Preprocessor preprocessor0;

void run() {

// The bug that started the whole work with the new preprocessor

TEST_CASE(Bug2190219);

TEST_CASE(error1); // #error => don't extract any code

TEST_CASE(error3);

TEST_CASE(error4); // #2919 - wrong filename is reported

TEST_CASE(error5);

TEST_CASE(setPlatformInfo);

// Handling include guards (don't create extra configuration for it)

TEST_CASE(includeguard1);

TEST_CASE(includeguard2);

TEST_CASE(if0);

TEST_CASE(if1);

TEST_CASE(elif);

TEST_CASE(if_cond1);

TEST_CASE(if_cond2);

TEST_CASE(if_cond3);

TEST_CASE(if_cond4);

TEST_CASE(if_cond5);

TEST_CASE(if_cond6);

TEST_CASE(if_cond8);

TEST_CASE(if_cond9);

TEST_CASE(if_cond10);

TEST_CASE(if_cond11);

TEST_CASE(if_cond12);

TEST_CASE(if_cond13);

TEST_CASE(if_cond14);

TEST_CASE(if_or_1);

TEST_CASE(if_or_2);

TEST_CASE(if_macro_eq_macro); // #3536

TEST_CASE(ticket_3675);

TEST_CASE(ticket_3699);

TEST_CASE(ticket_4922); // #4922

// Macros..

TEST_CASE(macro_simple1);

TEST_CASE(macro_simple2);

TEST_CASE(macro_simple3);

TEST_CASE(macro_simple4);

TEST_CASE(macro_simple5);

TEST_CASE(macro_simple6);

TEST_CASE(macro_simple7);

TEST_CASE(macro_simple8);

TEST_CASE(macro_simple9);

TEST_CASE(macro_simple10);

TEST_CASE(macro_simple11);

TEST_CASE(macro_simple12);

TEST_CASE(macro_simple13);

TEST_CASE(macro_simple14);

TEST_CASE(macro_simple15);

TEST_CASE(macro_simple16); // #4703: Macro parameters not trimmed

TEST_CASE(macro_simple17); // #5074: isExpandedMacro not set

TEST_CASE(macro_simple18); // (1e-7)

TEST_CASE(macroInMacro1);

TEST_CASE(macroInMacro2);

TEST_CASE(macro_linenumbers);

TEST_CASE(macro_nopar);

TEST_CASE(macro_incdec); // separate ++ and -- with space when expanding such macro: '#define M(X) A-X'

TEST_CASE(macro_switchCase);

TEST_CASE(macro_NULL); // skip #define NULL .. it is replaced in the tokenizer

TEST_CASE(string1);

TEST_CASE(string2);

TEST_CASE(string3);

TEST_CASE(preprocessor_undef);

TEST_CASE(defdef); // Defined multiple times

TEST_CASE(preprocessor_doublesharp);

TEST_CASE(preprocessor_include_in_str);

TEST_CASE(va_args_1);

//TEST_CASE(va_args_2); invalid code

TEST_CASE(va_args_3);

TEST_CASE(va_args_4);

TEST_CASE(va_args_5);

TEST_CASE(multi_character_character);

TEST_CASE(stringify);

TEST_CASE(stringify2);

TEST_CASE(stringify3);

TEST_CASE(stringify4);

TEST_CASE(stringify5);

TEST_CASE(ifdefwithfile);

TEST_CASE(pragma);

TEST_CASE(pragma_asm_1);

TEST_CASE(pragma_asm_2);

TEST_CASE(endifsemicolon);

TEST_CASE(missing_doublequote);

TEST_CASE(handle_error);

TEST_CASE(dup_defines);

TEST_CASE(define_part_of_func);

TEST_CASE(conditionalDefine);

TEST_CASE(macro_parameters);

TEST_CASE(newline_in_macro);

TEST_CASE(ifdef_ifdefined);

// define and then ifdef

TEST_CASE(define_if1);

TEST_CASE(define_if2);

TEST_CASE(define_if3);

TEST_CASE(define_if4); // #4079 - #define X +123

TEST_CASE(define_if5); // #4516 - #define B (A & 0x00f0)

TEST_CASE(define_if6); // #4863 - #define B (A?-1:1)

TEST_CASE(define_ifdef);

TEST_CASE(define_ifndef1);

TEST_CASE(define_ifndef2);

TEST_CASE(ifndef_define);

TEST_CASE(undef_ifdef);

TEST_CASE(endfile);

TEST_CASE(redundant_config);

TEST_CASE(invalid_define_1); // #2605 - hang for: '#define ='

TEST_CASE(invalid_define_2); // #4036 - hang for: '#define () {(int f(x) }'

// inline suppression, missingInclude

TEST_CASE(inline_suppression_for_missing_include);

// Using -D to predefine symbols

TEST_CASE(predefine1);

TEST_CASE(predefine2);

TEST_CASE(predefine3);

TEST_CASE(predefine4);

TEST_CASE(predefine5); // automatically define __cplusplus

TEST_CASE(invalidElIf); // #2942 segfault

// Preprocessor::getConfigs

TEST_CASE(getConfigs1);

TEST_CASE(getConfigs2);

TEST_CASE(getConfigs3);

TEST_CASE(getConfigs4);

TEST_CASE(getConfigs5);

TEST_CASE(getConfigs7);

TEST_CASE(getConfigs7a);

TEST_CASE(getConfigs7b);

TEST_CASE(getConfigs7c);

TEST_CASE(getConfigs7d);

TEST_CASE(getConfigs7e);

TEST_CASE(getConfigs8); // #if A==1 => cfg: A=1

TEST_CASE(getConfigs10); // #5139

TEST_CASE(getConfigsD1);

TEST_CASE(getConfigsU1);

TEST_CASE(getConfigsU2);

TEST_CASE(getConfigsU3);

TEST_CASE(getConfigsU4);

TEST_CASE(getConfigsU5);

TEST_CASE(getConfigsU6);

TEST_CASE(validateCfg);

TEST_CASE(if_sizeof);

TEST_CASE(invalid_ifs); // #5909

TEST_CASE(garbage);

TEST_CASE(wrongPathOnErrorDirective);

TEST_CASE(testDirectiveIncludeTypes);

TEST_CASE(testDirectiveIncludeLocations);

TEST_CASE(testDirectiveIncludeComments);

}

void preprocess(const char* code, std::map<std::string, std::string>& actual, const char filename[] = "file.c") {

errout.str("");

std::istringstream istr(code);

simplecpp::OutputList outputList;

std::vector<std::string> files;

simplecpp::TokenList tokens(istr, files, filename, &outputList);

tokens.removeComments();

const std::set<std::string> configs(preprocessor0.getConfigs(tokens));

preprocessor0.setDirectives(tokens);

for (std::set<std::string>::const_iterator it = configs.begin(); it != configs.end(); ++it) {

try {

const std::string &cfgcode = preprocessor0.getcode(tokens, *it, files, std::string(code).find("#file") != std::string::npos);

actual[*it] = cfgcode;

} catch (...) {

}

}

}

std::string getConfigsStr(const char filedata[], const char *arg=NULL) {

Settings settings;

if (arg && std::strncmp(arg,"-D",2)==0)

settings.userDefines = arg + 2;

if (arg && std::strncmp(arg,"-U",2)==0)

settings.userUndefs.insert(arg+2);

Preprocessor preprocessor(settings, this);

std::vector<std::string> files;

std::istringstream istr(filedata);

simplecpp::TokenList tokens(istr,files);

tokens.removeComments();

const std::set<std::string> configs = preprocessor.getConfigs(tokens);

std::string ret;

for (std::set<std::string>::const_iterator it = configs.begin(); it != configs.end(); ++it)

ret += *it + '\n';

return ret;

}

void Bug2190219() {

const char filedata[] = "#ifdef __cplusplus\n"

"cpp\n"

"#else\n"

"c\n"

"#endif";

{

// Preprocess => actual result..

std::map<std::string, std::string> actual;

preprocess(filedata, actual, "file.cpp");

// Compare results..

ASSERT_EQUALS(1U, actual.size());

ASSERT_EQUALS("\ncpp", actual[""]);

}

{

// Ticket #7102 - skip __cplusplus in C code

// Preprocess => actual result..

std::map<std::string, std::string> actual;

preprocess(filedata, actual, "file.c");

// Compare results..

ASSERT_EQUALS(1U, actual.size());

ASSERT_EQUALS("\n\n\nc", actual[""]);

}

}

void error1() {

const char filedata[] = "#ifdef A\n"

";\n"

"#else\n"

"#error abcd\n"

"#endif\n";

ASSERT_EQUALS("\nA\n", getConfigsStr(filedata));

}

void error3() {

errout.str("");

Settings settings;

settings.userDefines = "__cplusplus";

Preprocessor preprocessor(settings, this);

const std::string code("#error hello world!\n");

preprocessor.getcode(code, "X", "test.c");

ASSERT_EQUALS("[test.c:1]: (error) #error hello world!\n", errout.str());

}

// Ticket #2919 - wrong filename reported for #error

void error4() {

// In included file

{

errout.str("");

Settings settings;

settings.userDefines = "TEST";

Preprocessor preprocessor(settings, this);

const std::string code("#file \"ab.h\"\n#error hello world!\n#endfile");

preprocessor.getcode(code, "TEST", "test.c");

ASSERT_EQUALS("[ab.h:1]: (error) #error hello world!\n", errout.str());

}

// After including a file

{

errout.str("");

Settings settings;

settings.userDefines = "TEST";

Preprocessor preprocessor(settings, this);

const std::string code("#file \"ab.h\"\n\n#endfile\n#error aaa");

preprocessor.getcode(code, "TEST", "test.c");

ASSERT_EQUALS("[test.c:2]: (error) #error aaa\n", errout.str());

}

}

void error5() {

errout.str("");

Settings settings;

settings.userDefines = "FOO";

settings.force = true; // No message if --force is given

Preprocessor preprocessor(settings, this);

const std::string code("#error hello world!\n");

preprocessor.getcode(code, "X", "test.c");

ASSERT_EQUALS("", errout.str());

}

void setPlatformInfo() {

Settings settings;

Preprocessor preprocessor(settings, this);

// read code with simplecpp..

const char filedata[] = "#if sizeof(long) == 4\n"

"1\n"

"#else\n"

"2\n"

"#endif\n";

std::istringstream istr(filedata);

std::vector<std::string> files;

simplecpp::TokenList tokens(istr, files, "test.c");

// preprocess code with unix32 platform..

settings.platform(Settings::PlatformType::Unix32);

preprocessor.setPlatformInfo(&tokens);

ASSERT_EQUALS("\n1", preprocessor.getcode(tokens, "", files, false));

// preprocess code with unix64 platform..

settings.platform(Settings::PlatformType::Unix64);

preprocessor.setPlatformInfo(&tokens);

ASSERT_EQUALS("\n\n\n2", preprocessor.getcode(tokens, "", files, false));

}

void includeguard1() {

// Handling include guards..

const char filedata[] = "#file \"abc.h\"\n"

"#ifndef abcH\n"

"#define abcH\n"

"#endif\n"

"#endfile\n"

"#ifdef ABC\n"

"#endif";

ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));

}

void includeguard2() {

// Handling include guards..

const char filedata[] = "#file \"abc.h\"\n"

"foo\n"

"#ifdef ABC\n"

"\n"

"#endif\n"

"#endfile\n";

ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));

}

void ifdefwithfile() {

// Handling include guards..

const char filedata[] = "#ifdef ABC\n"

"#file \"abc.h\"\n"

"class A{};/*\n\n\n\n\n\n\n*/\n"

"#endfile\n"

"#endif\n"

"int main() {}\n";

// Preprocess => actual result..

std::map<std::string, std::string> actual;

preprocess(filedata, actual);

// Expected configurations: "" and "ABC"

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

ASSERT_EQUALS("\n\n\nint main ( ) { }", actual[""]);

ASSERT_EQUALS("\n#line 1 \"abc.h\"\nclass A { } ;\n#line 4 \"file.c\"\n int main ( ) { }", actual["ABC"]);

}

void if0() {

const char filedata[] = " # if /* comment */ 0 // comment\n"

"#ifdef WIN32\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if1() {

const char filedata[] = " # if /* comment */ 1 // comment\n"

"ABC\n"

" # endif \n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void elif() {

{

const char filedata[] = "#if DEF1\n"

"ABC\n"

"#elif DEF2\n"

"DEF\n"

"#endif\n";

ASSERT_EQUALS("\nDEF1\nDEF2\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if(defined DEF1)\n"

"ABC\n"

"#elif(defined DEF2)\n"

"DEF\n"

"#else\n"

"GHI\n"

"#endif\n";

ASSERT_EQUALS("\nDEF1\nDEF2\n", getConfigsStr(filedata));

}

}

void if_cond1() {

const char filedata[] = "#if LIBVER>100\n"

" A\n"

"#else\n"

" B\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nLIBVER=101\n", "\n", getConfigsStr(filedata));

}

void if_cond2() {

const char filedata[] = "#ifdef A\n"

"a\n"

"#endif\n"

"#if defined(A) && defined(B)\n"

"ab\n"

"#endif\n";

ASSERT_EQUALS("\nA\nA;B\n", getConfigsStr(filedata));

if_cond2b();

if_cond2c();

if_cond2d();

if_cond2e();

}

void if_cond2b() {

const char filedata[] = "#ifndef A\n"

"!a\n"

"#ifdef B\n"

"b\n"

"#endif\n"

"#else\n"

"a\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA;B\n", "\nA\nB\n", getConfigsStr(filedata));

}

void if_cond2c() {

const char filedata[] = "#ifndef A\n"

"!a\n"

"#ifdef B\n"

"b\n"

"#else\n"

"!b\n"

"#endif\n"

"#else\n"

"a\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA\nA;B\n", "\nA\nB\n", getConfigsStr(filedata));

}

void if_cond2d() {

const char filedata[] = "#ifndef A\n"

"!a\n"

"#ifdef B\n"

"b\n"

"#else\n"

"!b\n"

"#endif\n"

"#else\n"

"a\n"

"#ifdef B\n"

"b\n"

"#else\n"

"!b\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("\nA\nA;B\nB\n", getConfigsStr(filedata));

}

void if_cond2e() {

const char filedata[] = "#if !defined(A)\n"

"!a\n"

"#elif !defined(B)\n"

"!b\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA\nA;B", "\n", getConfigsStr(filedata));

}

void if_cond3() {

const char filedata[] = "#ifdef A\n"

"a\n"

"#if defined(B) && defined(C)\n"

"abc\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("\nA\nA;B;C\n", getConfigsStr(filedata));

}

void if_cond4() {

{

const char filedata[] = "#define A\n"

"#define B\n"

"#if defined A || defined B\n"

"ab\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if A\n"

"{\n"

"#if (defined(B))\n"

"foo();\n"

"#endif\n"

"}\n"

"#endif\n";

ASSERT_EQUALS("\nA\nA;B\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#define A\n"

"#define B\n"

"#if (defined A) || defined (B)\n"

"ab\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if (A)\n"

"foo();\n"

"#endif\n";

ASSERT_EQUALS("\nA\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if! A\n"

"foo();\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

}

void if_cond5() {

const char filedata[] = "#if defined(A) && defined(B)\n"

"ab\n"

"#endif\n"

"cd\n"

"#if defined(B) && defined(A)\n"

"ef\n"

"#endif\n";

ASSERT_EQUALS("\nA;B\n", getConfigsStr(filedata));

}

void if_cond6() {

const char filedata[] = "\n"

"#if defined(A) && defined(B))\n"

"#endif\n";

ASSERT_EQUALS("\nA;B\n", getConfigsStr(filedata));

}

void if_cond8() {

const char filedata[] = "#if defined(A) + defined(B) + defined(C) != 1\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA\n", "\nA;B;C\n", getConfigsStr(filedata));

}

void if_cond9() {

const char filedata[] = "#if !defined _A\n"

"abc\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_cond10() {

const char filedata[] = "#if !defined(a) && !defined(b)\n"

"#if defined(and)\n"

"#endif\n"

"#endif\n";

// Preprocess => don't crash..

std::map<std::string, std::string> actual;

preprocess(filedata, actual);

}

void if_cond11() {

const char filedata[] = "#if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE\n"

"#if LIBGCC2_HAS_DF_MODE\n"

"#elif FLT_MANT_DIG < W_TYPE_SIZE\n"

"#endif\n"

"#endif\n";

std::map<std::string, std::string> actual;

preprocess(filedata, actual);

ASSERT_EQUALS("", errout.str());

}

void if_cond12() {

const char filedata[] = "#define A (1)\n"

"#if A == 1\n"

";\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_cond13() {

const char filedata[] = "#if ('A' == 0x41)\n"

"123\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_cond14() {

const char filedata[] = "#if !(A)\n"

"123\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_or_1() {

const char filedata[] = "#if defined(DEF_10) || defined(DEF_11)\n"

"a1;\n"

"#endif\n";

ASSERT_EQUALS("\nDEF_10;DEF_11\n", getConfigsStr(filedata));

}

void if_or_2() {

const char filedata[] = "#if X || Y\n"

"a1;\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nX;Y\n", "\n", getConfigsStr(filedata));

}

void if_macro_eq_macro() {

const char *code = "#define A B\n"

"#define B 1\n"

"#define C 1\n"

"#if A == C\n"

"Wilma\n"

"#else\n"

"Betty\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(code));

}

void ticket_3675() {

const char* code = "#ifdef YYSTACKSIZE\n"

"#define YYMAXDEPTH YYSTACKSIZE\n"

"#else\n"

"#define YYSTACKSIZE YYMAXDEPTH\n"

"#endif\n"

"#if YYDEBUG\n"

"#endif\n";

std::map<std::string, std::string> actual;

preprocess(code, actual);

// There's nothing to assert. It just needs to not hang.

}

void ticket_3699() {

const char* code = "#define INLINE __forceinline\n"

"#define inline __forceinline\n"

"#define __forceinline inline\n"

"#if !defined(_WIN32)\n"

"#endif\n"

"INLINE inline __forceinline\n";

std::map<std::string, std::string> actual;

preprocess(code, actual);

// First, it must not hang. Second, inline must becomes inline, and __forceinline must become __forceinline.

ASSERT_EQUALS("\n\n\n\n\n$__forceinline $inline $__forceinline", actual[""]);

}

void ticket_4922() { // #4922

const char* code = "__asm__ \n"

"{ int extern __value) 0; (double return (\"\" } extern\n"

"__typeof __finite (__finite) __finite __inline \"__GI___finite\");";

std::map<std::string, std::string> actual;

preprocess(code, actual);

}

void macro_simple1() const {

{

const char filedata[] = "#define AAA(aa) f(aa)\n"

"AAA(5);\n";

ASSERT_EQUALS("\nf ( 5 ) ;", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] = "#define AAA(aa) f(aa)\n"

"AAA (5);\n";

ASSERT_EQUALS("\nf ( 5 ) ;", OurPreprocessor::expandMacros(filedata));

}

}

void macro_simple2() const {

const char filedata[] = "#define min(x,y) x<y?x:y\n"

"min(a(),b());\n";

ASSERT_EQUALS("\na ( ) < b ( ) ? a ( ) : b ( ) ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple3() const {

const char filedata[] = "#define A 4\n"

"A AA\n";

ASSERT_EQUALS("\n4 AA", OurPreprocessor::expandMacros(filedata));

}

void macro_simple4() const {

const char filedata[] = "#define TEMP_1 if( temp > 0 ) return 1;\n"

"TEMP_1\n";

ASSERT_EQUALS("\nif ( temp > 0 ) return 1 ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple5() const {

const char filedata[] = "#define ABC if( temp > 0 ) return 1;\n"

"\n"

"void foo()\n"

"{\n"

" int temp = 0;\n"

" ABC\n"

"}\n";

ASSERT_EQUALS("\n\nvoid foo ( )\n{\nint temp = 0 ;\nif ( temp > 0 ) return 1 ;\n}", OurPreprocessor::expandMacros(filedata));

}

void macro_simple6() const {

const char filedata[] = "#define ABC (a+b+c)\n"

"ABC\n";

ASSERT_EQUALS("\n( a + b + c )", OurPreprocessor::expandMacros(filedata));

}

void macro_simple7() const {

const char filedata[] = "#define ABC(str) str\n"

"ABC(\"(\")\n";

ASSERT_EQUALS("\n\"(\"", OurPreprocessor::expandMacros(filedata));

}

void macro_simple8() const {

const char filedata[] = "#define ABC 123\n"

"#define ABCD 1234\n"

"ABC ABCD\n";

ASSERT_EQUALS("\n\n123 1234", OurPreprocessor::expandMacros(filedata));

}

void macro_simple9() const {

const char filedata[] = "#define ABC(a) f(a)\n"

"ABC( \"\\\"\" );\n"

"ABC( \"g\" );\n";

ASSERT_EQUALS("\nf ( \"\\\"\" ) ;\nf ( \"g\" ) ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple10() const {

const char filedata[] = "#define ABC(t) t x\n"

"ABC(unsigned long);\n";

ASSERT_EQUALS("\nunsigned long x ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple11() const {

const char filedata[] = "#define ABC(x) delete x\n"

"ABC(a);\n";

ASSERT_EQUALS("\ndelete a ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple12() const {

const char filedata[] = "#define AB ab.AB\n"

"AB.CD\n";

ASSERT_EQUALS("\nab . AB . CD", OurPreprocessor::expandMacros(filedata));

}

void macro_simple13() const {

const char filedata[] = "#define TRACE(x)\n"

"TRACE(;if(a))\n";

ASSERT_EQUALS("", OurPreprocessor::expandMacros(filedata));

}

void macro_simple14() const {

const char filedata[] = "#define A \" a \"\n"

"printf(A);\n";

ASSERT_EQUALS("\nprintf ( \" a \" ) ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple15() const {

const char filedata[] = "#define FOO\"foo\"\n"

"FOO\n";

ASSERT_EQUALS("\n\"foo\"", OurPreprocessor::expandMacros(filedata));

}

void macro_simple16() const { // # 4703

const char filedata[] = "#define MACRO( A, B, C ) class A##B##C##Creator {};\n"

"MACRO( B\t, U , G )";

ASSERT_EQUALS("\nclass BUGCreator { } ;", OurPreprocessor::expandMacros(filedata));

}

void macro_simple17() const { // # 5074 - the Token::isExpandedMacro() doesn't always indicate properly if token comes from macro

// It would probably be OK if the generated code was

// "\n123+$123" since the first 123 comes from the source code

const char filedata[] = "#define MACRO(A) A+123\n"

"MACRO(123)";

ASSERT_EQUALS("\n123 + 123", OurPreprocessor::expandMacros(filedata));

}

void macro_simple18() const { // (1e-7)

const char filedata1[] = "#define A (1e-7)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 1e-7 ) ;", OurPreprocessor::expandMacros(filedata1));

const char filedata2[] = "#define A (1E-7)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 1E-7 ) ;", OurPreprocessor::expandMacros(filedata2));

const char filedata3[] = "#define A (1e+7)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 1e+7 ) ;", OurPreprocessor::expandMacros(filedata3));

const char filedata4[] = "#define A (1.e+7)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 1.e+7 ) ;", OurPreprocessor::expandMacros(filedata4));

const char filedata5[] = "#define A (1.7f)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 1.7f ) ;", OurPreprocessor::expandMacros(filedata5));

const char filedata6[] = "#define A (.1)\n"

"a=A;";

ASSERT_EQUALS("\na = ( .1 ) ;", OurPreprocessor::expandMacros(filedata6));

const char filedata7[] = "#define A (1.)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 1. ) ;", OurPreprocessor::expandMacros(filedata7));

const char filedata8[] = "#define A (8.0E+007)\n"

"a=A;";

ASSERT_EQUALS("\na = ( 8.0E+007 ) ;", OurPreprocessor::expandMacros(filedata8));

}

void macroInMacro1() const {

{

const char filedata[] = "#define A(m) long n = m; n++;\n"

"#define B(n) A(n)\n"

"B(0)\n";

ASSERT_EQUALS("\n\nlong n = 0 ; n ++ ;", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] = "#define A B\n"

"#define B 3\n"

"A\n";

ASSERT_EQUALS("\n\n3", OurPreprocessor::expandMacros(filedata));

}

{

/* TODO: What to do here? since there are syntax error simplecpp outputs ""

}

{

const char filedata[] = "#define A 4\n"

"#define B(a) a,A\n"

"B(2);\n";

ASSERT_EQUALS("\n\n2 , 4 ;", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] = "#define A(x) (x)\n"

"#define B )A(\n"

"#define C )A(\n";

ASSERT_EQUALS("", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] = "#define A(x) (x*2)\n"

"#define B A(\n"

"foo B(i));\n";

ASSERT_EQUALS("\n\nfoo ( ( i ) * 2 ) ;", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] = "#define foo foo\n"

"foo\n";

ASSERT_EQUALS("\nfoo", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] =

"#define B(A1, A2) } while (0)\n"

"#define A(name) void foo##name() { do { B(1, 2); }\n"

"A(0)\n"

"A(1)\n";

ASSERT_EQUALS("\n\nvoid foo0 ( ) { do { } while ( 0 ) ; }\nvoid foo1 ( ) { do { } while ( 0 ) ; }", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] =

"#define B(x) (\n"

"#define A() B(xx)\n"

"B(1) A() ) )\n";

ASSERT_EQUALS("\n\n( ( ) )", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] =

"#define PTR1 (\n"

"#define PTR2 PTR1 PTR1\n"

"int PTR2 PTR2 foo )))) = 0;\n";

ASSERT_EQUALS("\n\nint ( ( ( ( foo ) ) ) ) = 0 ;", OurPreprocessor::expandMacros(filedata));

}

{

const char filedata[] =

"#define PTR1 (\n"

"PTR1 PTR1\n";

ASSERT_EQUALS("\n( (", OurPreprocessor::expandMacros(filedata));

}

}

void macroInMacro2() const {

const char filedata[] = "#define A(x) a##x\n"

"#define B 0\n"

"A(B)\n";

ASSERT_EQUALS("\n\naB", OurPreprocessor::expandMacros(filedata));

}

void macro_linenumbers() const {

const char filedata[] = "#define AAA(a)\n"

"AAA(5\n"

"\n"

")\n"

"int a;\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"\n"

"int a ;",