/*

* simplecpp - A simple and high-fidelity C/C++ preprocessor library

* Copyright (C) 2016-2022 Daniel Marjamäki.

*

* This library is free software: you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation, either

* version 3 of the License, or (at your option) any later version.

*

* This library 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

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library. If not, see <http://www.gnu.org/licenses/>.

*/

#include <iostream>

#include <limits>

#include <sstream>

#include <vector>

#include "simplecpp.h"

static int numberOfFailedAssertions = 0;

#define ASSERT_EQUALS(expected, actual) (assertEquals((expected), (actual), __LINE__))

#define ASSERT_THROW(stmt, e) do { try { stmt; assertThrowFailed(__LINE__); } catch (const e&) {} } while(false)

static std::string pprint(const std::string &in)

{

std::string ret;

for (std::string::size_type i = 0; i < in.size(); ++i) {

if (in[i] == '\n')

ret += "\\n";

ret += in[i];

}

return ret;

}

static int assertEquals(const std::string &expected, const std::string &actual, int line)

{

if (expected != actual) {

numberOfFailedAssertions++;

std::cerr << "------ assertion failed ---------" << std::endl;

std::cerr << "line " << line << std::endl;

std::cerr << "expected:" << pprint(expected) << std::endl;

std::cerr << "actual:" << pprint(actual) << std::endl;

}

return (expected == actual);

}

static int assertEquals(const unsigned int &expected, const unsigned int &actual, int line)

{

return assertEquals(std::to_string(expected), std::to_string(actual), line);

}

static void assertThrowFailed(int line)

{

numberOfFailedAssertions++;

std::cerr << "------ assertion failed ---------" << std::endl;

std::cerr << "line " << line << std::endl;

std::cerr << "exception not thrown" << std::endl;

}

static void testcase(const std::string &name, void (*f)(), int argc, char * const *argv)

{

if (argc == 1)

f();

else {

for (int i = 1; i < argc; i++) {

if (name == argv[i])

f();

}

}

}

#define TEST_CASE(F) (testcase(#F, F, argc, argv))

static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)

{

std::istringstream istr(std::string(code, size));

return simplecpp::TokenList(istr,filenames,filename,outputList);

}

static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)

{

return makeTokenList(code, strlen(code), filenames, filename, outputList);

}

static std::string readfile(const char code[], simplecpp::OutputList *outputList=nullptr)

{

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

return makeTokenList(code,files,std::string(),outputList).stringify();

}

static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList *outputList=nullptr)

{

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

return makeTokenList(code,size,files,std::string(),outputList).stringify();

}

static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList)

{

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

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

simplecpp::TokenList tokens = makeTokenList(code,files);

tokens.removeComments();

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, tokens, files, filedata, dui, outputList);

return tokens2.stringify();

}

static std::string preprocess(const char code[])

{

return preprocess(code, simplecpp::DUI(), nullptr);

}

static std::string preprocess(const char code[], const simplecpp::DUI &dui)

{

return preprocess(code, dui, nullptr);

}

static std::string preprocess(const char code[], simplecpp::OutputList *outputList)

{

return preprocess(code, simplecpp::DUI(), outputList);

}

static std::string toString(const simplecpp::OutputList &outputList)

{

std::ostringstream ostr;

for (const simplecpp::Output &output : outputList) {

ostr << "file" << output.location.fileIndex << ',' << output.location.line << ',';

switch (output.type) {

case simplecpp::Output::Type::ERROR:

ostr << "#error,";

break;

case simplecpp::Output::Type::WARNING:

ostr << "#warning,";

break;

case simplecpp::Output::Type::MISSING_HEADER:

ostr << "missing_header,";

break;

case simplecpp::Output::Type::INCLUDE_NESTED_TOO_DEEPLY:

ostr << "include_nested_too_deeply,";

break;

case simplecpp::Output::Type::SYNTAX_ERROR:

ostr << "syntax_error,";

break;

case simplecpp::Output::Type::PORTABILITY_BACKSLASH:

ostr << "portability_backslash,";

break;

case simplecpp::Output::Type::UNHANDLED_CHAR_ERROR:

ostr << "unhandled_char_error,";

break;

case simplecpp::Output::Type::EXPLICIT_INCLUDE_NOT_FOUND:

ostr << "explicit_include_not_found,";

}

ostr << output.msg << '\n';

}

return ostr.str();

}

static void backslash()

{

// <backslash><space><newline> preprocessed differently

simplecpp::OutputList outputList;

readfile("//123 \\\n456", &outputList);

ASSERT_EQUALS("", toString(outputList));

readfile("//123 \\ \n456", &outputList);

ASSERT_EQUALS("file0,1,portability_backslash,Combination 'backslash space newline' is not portable.\n", toString(outputList));

outputList.clear();

readfile("#define A \\\n123", &outputList);

ASSERT_EQUALS("", toString(outputList));

readfile("#define A \\ \n123", &outputList);

ASSERT_EQUALS("file0,1,portability_backslash,Combination 'backslash space newline' is not portable.\n", toString(outputList));

}

static void builtin()

{

ASSERT_EQUALS("\"\" 1 0", preprocess("__FILE__ __LINE__ __COUNTER__"));

ASSERT_EQUALS("\n\n3", preprocess("\n\n__LINE__"));

ASSERT_EQUALS("\n\n0", preprocess("\n\n__COUNTER__"));

ASSERT_EQUALS("\n\n0 1", preprocess("\n\n__COUNTER__ __COUNTER__"));

ASSERT_EQUALS("\n0 + 0", preprocess("#define A(c) c+c\n"

"A(__COUNTER__)\n"));

ASSERT_EQUALS("\n0 + 0 + 1", preprocess("#define A(c) c+c+__COUNTER__\n"

"A(__COUNTER__)\n"));

}

static std::string testConstFold(const char code[])

{

try {

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

simplecpp::TokenList expr = makeTokenList(code, files);

expr.constFold();

return expr.stringify();

} catch (std::exception &) {

return "exception";

}

}

static void characterLiteral()

{

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("'A'"));

ASSERT_EQUALS('\'', simplecpp::characterLiteralToLL("'\\''"));

ASSERT_EQUALS('\"', simplecpp::characterLiteralToLL("'\\\"'"));

ASSERT_EQUALS('\?', simplecpp::characterLiteralToLL("'\\?'"));

ASSERT_EQUALS('\\', simplecpp::characterLiteralToLL("'\\\\'"));

ASSERT_EQUALS('\a', simplecpp::characterLiteralToLL("'\\a'"));

ASSERT_EQUALS('\b', simplecpp::characterLiteralToLL("'\\b'"));

ASSERT_EQUALS('\f', simplecpp::characterLiteralToLL("'\\f'"));

ASSERT_EQUALS('\n', simplecpp::characterLiteralToLL("'\\n'"));

ASSERT_EQUALS('\r', simplecpp::characterLiteralToLL("'\\r'"));

ASSERT_EQUALS('\t', simplecpp::characterLiteralToLL("'\\t'"));

ASSERT_EQUALS('\v', simplecpp::characterLiteralToLL("'\\v'"));

// GCC extension for ESC character

ASSERT_EQUALS(0x1b, simplecpp::characterLiteralToLL("'\\e'"));

ASSERT_EQUALS(0x1b, simplecpp::characterLiteralToLL("'\\E'"));

// more obscure GCC extensions

ASSERT_EQUALS('(', simplecpp::characterLiteralToLL("'\\('"));

ASSERT_EQUALS('[', simplecpp::characterLiteralToLL("'\\['"));

ASSERT_EQUALS('{', simplecpp::characterLiteralToLL("'\\{'"));

ASSERT_EQUALS('%', simplecpp::characterLiteralToLL("'\\%'"));

ASSERT_EQUALS('\0', simplecpp::characterLiteralToLL("'\\0'"));

ASSERT_EQUALS('\1', simplecpp::characterLiteralToLL("'\\1'"));

ASSERT_EQUALS('\10', simplecpp::characterLiteralToLL("'\\10'"));

ASSERT_EQUALS('\010', simplecpp::characterLiteralToLL("'\\010'"));

ASSERT_EQUALS('\377', simplecpp::characterLiteralToLL("'\\377'"));

ASSERT_EQUALS('\x0', simplecpp::characterLiteralToLL("'\\x0'"));

ASSERT_EQUALS('\x10', simplecpp::characterLiteralToLL("'\\x10'"));

ASSERT_EQUALS('\xff', simplecpp::characterLiteralToLL("'\\xff'"));

ASSERT_EQUALS('\u0012', simplecpp::characterLiteralToLL("'\\u0012'"));

ASSERT_EQUALS('\U00000012', simplecpp::characterLiteralToLL("'\\U00000012'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('b')) << 8) | static_cast<unsigned char>('c'), simplecpp::characterLiteralToLL("'bc'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\x23')) << 8) | static_cast<unsigned char>('\x45'), simplecpp::characterLiteralToLL("'\\x23\\x45'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\11')) << 8) | static_cast<unsigned char>('\222'), simplecpp::characterLiteralToLL("'\\11\\222'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\a')) << 8) | static_cast<unsigned char>('\b'), simplecpp::characterLiteralToLL("'\\a\\b'"));

if (sizeof(int) <= 4)

ASSERT_EQUALS(-1, simplecpp::characterLiteralToLL("'\\xff\\xff\\xff\\xff'"));

else

ASSERT_EQUALS(0xffffffff, simplecpp::characterLiteralToLL("'\\xff\\xff\\xff\\xff'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("u8'A'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("u'A'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("L'A'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("U'A'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("u8'\\xff'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("u'\\xff'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("L'\\xff'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("U'\\xff'"));

ASSERT_EQUALS(0xfedc, simplecpp::characterLiteralToLL("u'\\xfedc'"));

ASSERT_EQUALS(0xfedcba98, simplecpp::characterLiteralToLL("L'\\xfedcba98'"));

ASSERT_EQUALS(0xfedcba98, simplecpp::characterLiteralToLL("U'\\xfedcba98'"));

ASSERT_EQUALS(0x12, simplecpp::characterLiteralToLL("u8'\\u0012'"));

ASSERT_EQUALS(0x1234, simplecpp::characterLiteralToLL("u'\\u1234'"));

ASSERT_EQUALS(0x00012345, simplecpp::characterLiteralToLL("L'\\U00012345'"));

ASSERT_EQUALS(0x00012345, simplecpp::characterLiteralToLL("U'\\U00012345'"));

#ifdef __GNUC__

// BEGIN Implementation-specific results

ASSERT_EQUALS(static_cast<int>('AB'), simplecpp::characterLiteralToLL("'AB'"));

ASSERT_EQUALS(static_cast<int>('ABC'), simplecpp::characterLiteralToLL("'ABC'"));

ASSERT_EQUALS(static_cast<int>('ABCD'), simplecpp::characterLiteralToLL("'ABCD'"));

ASSERT_EQUALS('\134t', simplecpp::characterLiteralToLL("'\\134t'")); // cppcheck ticket #7452

// END Implementation-specific results

#endif

ASSERT_THROW(simplecpp::characterLiteralToLL("'\\9'"), std::runtime_error);

// Input is manually encoded to (escaped) UTF-8 byte sequences

// to avoid dependence on source encoding used for this file

ASSERT_EQUALS(0xb5, simplecpp::characterLiteralToLL("U'\302\265'"));

ASSERT_EQUALS(0x157, simplecpp::characterLiteralToLL("U'\305\227'"));

ASSERT_EQUALS(0xff0f, simplecpp::characterLiteralToLL("U'\357\274\217'"));

ASSERT_EQUALS(0x3042, simplecpp::characterLiteralToLL("U'\343\201\202'"));

ASSERT_EQUALS(0x13000, simplecpp::characterLiteralToLL("U'\360\223\200\200'"));

ASSERT_EQUALS(0xb5, simplecpp::characterLiteralToLL("L'\302\265'"));

ASSERT_EQUALS(0x157, simplecpp::characterLiteralToLL("L'\305\227'"));

ASSERT_EQUALS(0xff0f, simplecpp::characterLiteralToLL("L'\357\274\217'"));

ASSERT_EQUALS(0x3042, simplecpp::characterLiteralToLL("L'\343\201\202'"));

ASSERT_EQUALS(0x13000, simplecpp::characterLiteralToLL("L'\360\223\200\200'"));

ASSERT_EQUALS(0xb5, simplecpp::characterLiteralToLL("u'\302\265'"));

ASSERT_EQUALS(0x157, simplecpp::characterLiteralToLL("u'\305\227'"));

ASSERT_EQUALS(0xff0f, simplecpp::characterLiteralToLL("u'\357\274\217'"));

ASSERT_EQUALS(0x3042, simplecpp::characterLiteralToLL("u'\343\201\202'"));

ASSERT_THROW(simplecpp::characterLiteralToLL("u'\360\223\200\200'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("u8'\302\265'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("u8'\305\227'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("u8'\357\274\217'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("u8'\343\201\202'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("u8'\360\223\200\200'"), std::runtime_error);

ASSERT_EQUALS('\x89', simplecpp::characterLiteralToLL("'\x89'"));

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\x89'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf4\x90\x80\x80'"), std::runtime_error);

// following examples based on https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt

ASSERT_EQUALS(0x80, simplecpp::characterLiteralToLL("U'\xc2\x80'"));

ASSERT_EQUALS(0x800, simplecpp::characterLiteralToLL("U'\xe0\xa0\x80'"));

ASSERT_EQUALS(0x10000, simplecpp::characterLiteralToLL("U'\xf0\x90\x80\x80'"));

ASSERT_EQUALS(0x7f, simplecpp::characterLiteralToLL("U'\x7f'"));

ASSERT_EQUALS(0x7ff, simplecpp::characterLiteralToLL("U'\xdf\xbf'"));

ASSERT_EQUALS(0xffff, simplecpp::characterLiteralToLL("U'\xef\xbf\xbf'"));

ASSERT_EQUALS(0xd7ff, simplecpp::characterLiteralToLL("U'\xed\x9f\xbf'"));

ASSERT_EQUALS(0xe000, simplecpp::characterLiteralToLL("U'\xee\x80\x80'"));

ASSERT_EQUALS(0xfffd, simplecpp::characterLiteralToLL("U'\xef\xbf\xbd'"));

ASSERT_EQUALS(0x10ffff, simplecpp::characterLiteralToLL("U'\xf4\x8f\xbf\xbf'"));

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\x80'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\x80\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\x80\x8f\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\x80\x8f\x8f\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xbf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xbf\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xbf\x8f\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xbf\x8f\x8f\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xc0'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xc0 '"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xe0\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xe0\x8f '"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf0\x8f\x8f'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf0\x8f\x8f '"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf8'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xff'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xc0\xaf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xe0\x80\xaf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf0\x80\x80\xaf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xc1\xbf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xe0\x9f\xbf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf0\x8f\xbf\xbf'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xc0\x80'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xe0\x80\x80'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xf0\x80\x80\x80'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xed\xa0\x80'"), std::runtime_error);

ASSERT_THROW(simplecpp::characterLiteralToLL("U'\xed\xbf\xbf'"), std::runtime_error);

}

static void combineOperators_floatliteral()

{

ASSERT_EQUALS("1.", preprocess("1."));

ASSERT_EQUALS("1.f", preprocess("1.f"));

ASSERT_EQUALS(".1", preprocess(".1"));

ASSERT_EQUALS(".1f", preprocess(".1f"));

ASSERT_EQUALS("3.1", preprocess("3.1"));

ASSERT_EQUALS("1E7", preprocess("1E7"));

ASSERT_EQUALS("1E-7", preprocess("1E-7"));

ASSERT_EQUALS("1E+7", preprocess("1E+7"));

ASSERT_EQUALS("1.e+7", preprocess("1.e+7"));

ASSERT_EQUALS("0x1E + 7", preprocess("0x1E+7"));

ASSERT_EQUALS("0x1ffp10", preprocess("0x1ffp10"));

ASSERT_EQUALS("0x0p-1", preprocess("0x0p-1"));

ASSERT_EQUALS("0x1.p0", preprocess("0x1.p0"));

ASSERT_EQUALS("0xf.p-1", preprocess("0xf.p-1"));

ASSERT_EQUALS("0x1.2p3", preprocess("0x1.2p3"));

ASSERT_EQUALS("0x1.ap3", preprocess("0x1.ap3"));

ASSERT_EQUALS("0x1.2ap3", preprocess("0x1.2ap3"));

ASSERT_EQUALS("0x1p+3", preprocess("0x1p+3"));

ASSERT_EQUALS("0x1p+3f", preprocess("0x1p+3f"));

ASSERT_EQUALS("0x1p+3L", preprocess("0x1p+3L"));

ASSERT_EQUALS("1p + 3", preprocess("1p+3"));

}

static void combineOperators_increment()

{

ASSERT_EQUALS("; ++ x ;", preprocess(";++x;"));

ASSERT_EQUALS("; x ++ ;", preprocess(";x++;"));

ASSERT_EQUALS("1 + + 2", preprocess("1++2"));

}

static void combineOperators_coloncolon()

{

ASSERT_EQUALS("x ? y : :: z", preprocess("x ? y : ::z"));

}

static void combineOperators_andequal()

{

ASSERT_EQUALS("x &= 2 ;", preprocess("x &= 2;"));

ASSERT_EQUALS("void f ( x & = 2 ) ;", preprocess("void f(x &= 2);"));

ASSERT_EQUALS("f ( x &= 2 ) ;", preprocess("f(x &= 2);"));

}

static void combineOperators_ellipsis()

{

ASSERT_EQUALS("void f ( int , ... ) ;", preprocess("void f(int, ...);"));

ASSERT_EQUALS("void f ( ) { switch ( x ) { case 1 ... 4 : } }", preprocess("void f() { switch(x) { case 1 ... 4: } }"));

}

static void comment()

{

ASSERT_EQUALS("// abc", readfile("// abc"));

ASSERT_EQUALS("", preprocess("// abc"));

ASSERT_EQUALS("/*\n\n*/abc", readfile("/*\n\n*/abc"));

ASSERT_EQUALS("\n\nabc", preprocess("/*\n\n*/abc"));

ASSERT_EQUALS("* p = a / * b / * c ;", readfile("*p=a/ *b/ *c;"));

ASSERT_EQUALS("* p = a / * b / * c ;", preprocess("*p=a/ *b/ *c;"));

}

static void comment_multiline()

{

const char code[] = "#define ABC {// \\\n"

"}\n"

"void f() ABC\n";

ASSERT_EQUALS("\n\nvoid f ( ) { }", preprocess(code));

}

static void constFold()

{

ASSERT_EQUALS("7", testConstFold("1+2*3"));

ASSERT_EQUALS("15", testConstFold("1+2*(3+4)"));

ASSERT_EQUALS("123", testConstFold("+123"));

ASSERT_EQUALS("1", testConstFold("-123<1"));

ASSERT_EQUALS("6", testConstFold("14 & 7"));

ASSERT_EQUALS("29", testConstFold("13 ^ 16"));

ASSERT_EQUALS("25", testConstFold("24 | 1"));

ASSERT_EQUALS("2", testConstFold("1?2:3"));

ASSERT_EQUALS("24", testConstFold("010+020"));

ASSERT_EQUALS("1", testConstFold("010==8"));

ASSERT_EQUALS("exception", testConstFold("!1 ? 2 :"));

ASSERT_EQUALS("exception", testConstFold("?2:3"));

}

static void convertCygwinPath()

{

// absolute paths

ASSERT_EQUALS("X:\\", simplecpp::convertCygwinToWindowsPath("/cygdrive/x")); // initial backslash

ASSERT_EQUALS("X:\\", simplecpp::convertCygwinToWindowsPath("/cygdrive/x/"));

ASSERT_EQUALS("X:\\dir", simplecpp::convertCygwinToWindowsPath("/cygdrive/x/dir"));

ASSERT_EQUALS("X:\\dir\\file", simplecpp::convertCygwinToWindowsPath("/cygdrive/x/dir/file"));

// relative paths

ASSERT_EQUALS("file", simplecpp::convertCygwinToWindowsPath("file"));

ASSERT_EQUALS("dir\\file", simplecpp::convertCygwinToWindowsPath("dir/file"));

ASSERT_EQUALS("..\\dir\\file", simplecpp::convertCygwinToWindowsPath("../dir/file"));

// incorrect Cygwin paths

ASSERT_EQUALS("\\cygdrive", simplecpp::convertCygwinToWindowsPath("/cygdrive"));

ASSERT_EQUALS("\\cygdrive\\", simplecpp::convertCygwinToWindowsPath("/cygdrive/"));

}

static void define1()

{

const char code[] = "#define A 1+2\n"

"a=A+3;";

ASSERT_EQUALS("# define A 1 + 2\n"

"a = A + 3 ;",

readfile(code));

ASSERT_EQUALS("\na = 1 + 2 + 3 ;",

preprocess(code));

}

static void define2()

{

const char code[] = "#define ADD(A,B) A+B\n"

"ADD(1+2,3);";

ASSERT_EQUALS("# define ADD ( A , B ) A + B\n"

"ADD ( 1 + 2 , 3 ) ;",

readfile(code));

ASSERT_EQUALS("\n1 + 2 + 3 ;",

preprocess(code));

}

static void define3()

{

const char code[] = "#define A 123\n"

"#define B A\n"

"A B";

ASSERT_EQUALS("# define A 123\n"

"# define B A\n"

"A B",

readfile(code));

ASSERT_EQUALS("\n\n123 123",

preprocess(code));

}

static void define4()

{

const char code[] = "#define A 123\n"

"#define B(C) A\n"

"A B(1)";

ASSERT_EQUALS("# define A 123\n"

"# define B ( C ) A\n"

"A B ( 1 )",

readfile(code));

ASSERT_EQUALS("\n\n123 123",

preprocess(code));

}

static void define5()

{

const char code[] = "#define add(x,y) x+y\n"

"add(add(1,2),3)";

ASSERT_EQUALS("\n1 + 2 + 3", preprocess(code));

}

static void define6()

{

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

"A()";

ASSERT_EQUALS("\n1", preprocess(code));

}

static void define7()

{

const char code[] = "#define A(X) X+1\n"

"A(1 /*23*/)";

ASSERT_EQUALS("\n1 + 1", preprocess(code));

}

static void define8() // 6.10.3.10

{

const char code[] = "#define A(X) \n"

"int A[10];";

ASSERT_EQUALS("\nint A [ 10 ] ;", preprocess(code));

}

static void define9()

{

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

"AB.CD\n";

ASSERT_EQUALS("\nab . AB . CD", preprocess(code));

}

static void define10() // don't combine prefix with space in macro

{

const char code[] = "#define A u8 \"a b\"\n"

"A;";

ASSERT_EQUALS("\nu8 \"a b\" ;", preprocess(code));

}

static void define11() // location of expanded argument

{

const char code[] = "#line 4 \"version.h\"\n"

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

"#define B(x) x\n"

"#define VER A(1)\n"

"\n"

"#line 10 \"cppcheck.cpp\"\n"

"VER;";

ASSERT_EQUALS("\n#line 10 \"cppcheck.cpp\"\n1 ;", preprocess(code));

}

static void define_invalid_1()

{

const char code[] = "#define A(\nB\n";

simplecpp::OutputList outputList;

ASSERT_EQUALS("", preprocess(code, &outputList));

ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define\n", toString(outputList));

}

static void define_invalid_2()

{

const char code[] = "#define\nhas#";

simplecpp::OutputList outputList;

ASSERT_EQUALS("", preprocess(code, &outputList));

ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define\n", toString(outputList));

}

static void define_define_1()

{

const char code[] = "#define A(x) (x+1)\n"

"#define B A(\n"

"B(i))";

ASSERT_EQUALS("\n\n( ( i ) + 1 )", preprocess(code));

}

static void define_define_2()

{

const char code[] = "#define A(m) n=m\n"

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

"B(0)";

ASSERT_EQUALS("\n\nn = 0", preprocess(code));

}

static void define_define_3()

{

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

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

"A(BC)";

ASSERT_EQUALS("\n\n123", preprocess(code));

}

static void define_define_4()

{

const char code[] = "#define FOO1()\n"

"#define TEST(FOO) FOO FOO()\n"

"TEST(FOO1)";

ASSERT_EQUALS("\n\nFOO1", preprocess(code));

}

static void define_define_5()

{

const char code[] = "#define X() Y\n"

"#define Y() X\n"

"A: X()()()\n";

// mcpp outputs "A: X()" and gcc/clang/vc outputs "A: Y"

ASSERT_EQUALS("\n\nA : Y", preprocess(code)); // <- match the output from gcc/clang/vc

}

static void define_define_6()

{

const char code1[] = "#define f(a) a*g\n"

"#define g f\n"

"a: f(2)(9)\n";

ASSERT_EQUALS("\n\na : 2 * f ( 9 )", preprocess(code1));

const char code2[] = "#define f(a) a*g\n"

"#define g(a) f(a)\n"

"a: f(2)(9)\n";

ASSERT_EQUALS("\n\na : 2 * 9 * g", preprocess(code2));

}

static void define_define_7()

{

const char code[] = "#define f(x) g(x\n"

"#define g(x) x()\n"

"f(f))\n";

ASSERT_EQUALS("\n\nf ( )", preprocess(code));

}

static void define_define_8() // line break in nested macro call

{

const char code[] = "#define A(X,Y) ((X)*(Y))\n"

"#define B(X,Y) ((X)+(Y))\n"

"B(0,A(255,x+\n"

"y))\n";

ASSERT_EQUALS("\n\n( ( 0 ) + ( ( ( 255 ) * ( x + y ) ) ) )", preprocess(code));

}

static void define_define_9() // line break in nested macro call

{

const char code[] = "#define A(X) X\n"

"#define B(X) X\n"

"A(\nB(dostuff(1,\n2)))\n";

ASSERT_EQUALS("\n\ndostuff ( 1 , 2 )", preprocess(code));

}

static void define_define_10()

{

const char code[] = "#define glue(a, b) a ## b\n"

"#define xglue(a, b) glue(a, b)\n"

"#define AB 1\n"

"#define B B 2\n"

"xglue(A, B)\n";

ASSERT_EQUALS("\n\n\n\n1 2", preprocess(code));

}

static void define_define_11()

{

const char code[] = "#define XY(x, y) x ## y\n"

"#define XY2(x, y) XY(x, y)\n"

"#define PORT XY2(P, 2)\n"

"#define ABC XY2(PORT, DIR)\n"

"ABC;\n";

ASSERT_EQUALS("\n\n\n\nP2DIR ;", preprocess(code));

}

static void define_define_12()

{

const char code[] = "#define XY(Z) Z\n"

"#define X(ID) X##ID(0)\n"

"X(Y)\n";

ASSERT_EQUALS("\n\n0", preprocess(code));

}

static void define_define_13() // issue #49 - empty macro

{

const char code[] = "#define f()\n"

"#define t(a) a\n"

"(t(f))\n";

ASSERT_EQUALS("\n\n( f )", preprocess(code));

}

static void define_define_14() // issue #58 - endless recursion

{

const char code[] = "#define z f(w\n"

"#define f()\n"

"#define w f(z\n"

"w\n";

ASSERT_EQUALS("\n\n\nf ( f ( w", preprocess(code)); // Don't crash

}

static void define_define_15() // issue #72 without __VA_ARGS__

{

const char code[] = "#define a f\n"

"#define foo(x,y) a(x,y)\n"

"#define f(x, y) x y\n"

"foo(1,2)";

ASSERT_EQUALS("\n\n\n1 2", preprocess(code));

}

static void define_define_16() // issue #72 with __VA_ARGS__

{

const char code[] = "#define ab(a, b) a##b\n"

"#define foo(...) ab(f, 2) (__VA_ARGS__)\n"

"#define f2(x, y) x y\n"

"foo(1,2)";

ASSERT_EQUALS("\n\n\n1 2", preprocess(code));

}

static void define_define_17()

{

const char code[] = "#define Bar(x) x\n"

"#define Foo Bar(1)\n"

"Bar( Foo ) ;";

ASSERT_EQUALS("\n\n1 ;", preprocess(code));

}

static void define_define_18()

{

const char code[] = "#define FOO(v) BAR(v, 0)\n"

"#define BAR(v, x) (v)\n"

"#define var (p->var)\n"

"FOO(var);";

ASSERT_EQUALS("\n\n\n( ( p -> var ) ) ;", preprocess(code));

}

static void define_va_args_1()

{

const char code[] = "#define A(fmt...) dostuff(fmt)\n"

"A(1,2);";

ASSERT_EQUALS("\ndostuff ( 1 , 2 ) ;", preprocess(code));

}

static void define_va_args_2()

{

const char code[] = "#define A(X,...) X(#__VA_ARGS__)\n"

"A(f,123);";

ASSERT_EQUALS("\nf ( \"123\" ) ;", preprocess(code));

}

static void define_va_args_3() // min number of arguments

{

const char code[] = "#define A(x, y, z...) 1\n"

"A(1, 2)\n";

ASSERT_EQUALS("\n1", preprocess(code));

}

static void define_ifdef()

{

const char code[] = "#define A(X) X\n"

"A(1\n"

"#ifdef CFG\n"

"#endif\n"

")\n";

simplecpp::OutputList outputList;

ASSERT_EQUALS("", preprocess(code, &outputList));

ASSERT_EQUALS("file0,3,syntax_error,failed to expand 'A', it is invalid to use a preprocessor directive as macro parameter\n", toString(outputList));

}

static void dollar()

{

ASSERT_EQUALS("$ab", readfile("$ab"));

ASSERT_EQUALS("a$b", readfile("a$b"));

}

static void error1()

{

const char code[] = "#error hello world!\n";

simplecpp::OutputList outputList;

ASSERT_EQUALS("", preprocess(code, &outputList));

ASSERT_EQUALS("file0,1,#error,#error hello world!\n", toString(outputList));

}

static void error2()

{

const char code[] = "#error it's an error\n";

simplecpp::OutputList outputList;

ASSERT_EQUALS("", preprocess(code, &outputList));

ASSERT_EQUALS("file0,1,#error,#error it's an error\n", toString(outputList));

}

static void error3()

{

const char code[] = "#error \"bla bla\\\n"

" bla bla.\"\n";

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

simplecpp::OutputList outputList;

const simplecpp::TokenList rawtokens = makeTokenList(code, files, "test.c", &outputList);

ASSERT_EQUALS("", toString(outputList));

}

static void error4()

{

// "#error x\n1"

const char code[] = "\xFE\xFF\x00\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x31";

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

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

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

const simplecpp::TokenList rawtoken = makeTokenList(code, sizeof(code),files,"test.c");

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

ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));

}

static void error5()

{

// "#error x\n1"

const char code[] = "\xFF\xFE\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x78\x00\x31\x00";

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

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

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

const simplecpp::TokenList rawtokens = makeTokenList(code, sizeof(code),files,"test.c");

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

ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));

}

static void garbage()

{

simplecpp::OutputList outputList;

outputList.clear();

ASSERT_EQUALS("", preprocess("#ifdef\n", &outputList));

ASSERT_EQUALS("file0,1,syntax_error,Syntax error in #ifdef\n", toString(outputList));

outputList.clear();

ASSERT_EQUALS("", preprocess("#define TEST2() A ##\nTEST2()\n", &outputList));

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'TEST2', Invalid ## usage when expanding 'TEST2': Unexpected newline\n", toString(outputList));

outputList.clear();

ASSERT_EQUALS("", preprocess("#define CON(a,b) a##b##\nCON(1,2)\n", &outputList));

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'CON', Invalid ## usage when expanding 'CON': Unexpected newline\n", toString(outputList));

}

static void garbage_endif()

{

simplecpp::OutputList outputList;

outputList.clear();

ASSERT_EQUALS("", preprocess("#elif A<0\n", &outputList));

ASSERT_EQUALS("file0,1,syntax_error,#elif without #if\n", toString(outputList));

outputList.clear();

ASSERT_EQUALS("", preprocess("#else\n", &outputList));

ASSERT_EQUALS("file0,1,syntax_error,#else without #if\n", toString(outputList));

outputList.clear();

ASSERT_EQUALS("", preprocess("#endif\n", &outputList));

ASSERT_EQUALS("file0,1,syntax_error,#endif without #if\n", toString(outputList));

}

static void hash()

{

ASSERT_EQUALS("x = \"1\"", preprocess("x=#__LINE__"));

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

"a(1)\n"

"a(2+3)";

ASSERT_EQUALS("\n"

"\"1\"\n"

"\"2+3\"", preprocess(code));

ASSERT_EQUALS("\n\"\\\"abc\\\\0\\\"\"", preprocess("#define str(x) #x\nstr(\"abc\\0\")\n"));

ASSERT_EQUALS("\n\n( \"123\" )",

preprocess("#define A(x) (x)\n"

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

"B(123)"));

}

static void hashhash1() // #4703

{

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

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

ASSERT_EQUALS("\nclass BUGCreator { } ;", preprocess(code));

}

static void hashhash2()

{

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

"#define B 0\n"

"A(B)";

ASSERT_EQUALS("\n\naB", preprocess(code));

}

static void hashhash3()

{

const char code[] = "#define A(B) A##B\n"

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

"a(A(B))";

ASSERT_EQUALS("\n\nAAB", preprocess(code));

}

static void hashhash4() // nonstandard gcc/clang extension for empty varargs

{

const char *code;

code = "#define A(x,y...) a(x,##y)\n"

"A(1)\n";

ASSERT_EQUALS("\na ( 1 )", preprocess(code));

code = "#define A(x, ...) a(x, ## __VA_ARGS__)\n"

"#define B(x, ...) A(x, ## __VA_ARGS__)\n"

"B(1);";

ASSERT_EQUALS("\n\na ( 1 ) ;", preprocess(code));

}

static void hashhash5()

{

ASSERT_EQUALS("x1", preprocess("x##__LINE__"));

}

static void hashhash6()

{

const char *code;

code = "#define A(X, ...) LOG(X, ##__VA_ARGS__)\n"

"A(1,(int)2)";

ASSERT_EQUALS("\nLOG ( 1 , ( int ) 2 )", preprocess(code));

code = "#define A(X, ...) LOG(X, ##__VA_ARGS__)\n"

"#define B(X, ...) A(X, ##__VA_ARGS__)\n"

"#define C(X, ...) B(X, ##__VA_ARGS__)\n"

"C(1,(int)2)";

ASSERT_EQUALS("\n\n\nLOG ( 1 , ( int ) 2 )", preprocess(code));

}

static void hashhash7() // # ## # (C standard; 6.10.3.3.p4)

{

const char *code;

code = "#define hash_hash # ## #\n"

"x hash_hash y";

ASSERT_EQUALS("\nx ## y", preprocess(code));

}

static void hashhash8()

{

const char code[] = "#define a(xy) x##y = xy\n"

"a(123);";

ASSERT_EQUALS("\nxy = 123 ;", preprocess(code));

}

static void hashhash9()

{

const char * code = "#define ADD_OPERATOR(OP) void operator OP ## = (void) { x = x OP 1; }\n"

"ADD_OPERATOR(+);\n"

"ADD_OPERATOR(-);\n"

"ADD_OPERATOR(*);\n"

"ADD_OPERATOR(/);\n"

"ADD_OPERATOR(%);\n"

"ADD_OPERATOR(&);\n"

"ADD_OPERATOR(|);\n"

"ADD_OPERATOR(^);\n"

"ADD_OPERATOR(<<);\n"

"ADD_OPERATOR(>>);\n";

const char expected[] = "\n"

"void operator += ( void ) { x = x + 1 ; } ;\n"

"void operator -= ( void ) { x = x - 1 ; } ;\n"

"void operator *= ( void ) { x = x * 1 ; } ;\n"

"void operator /= ( void ) { x = x / 1 ; } ;\n"

"void operator %= ( void ) { x = x % 1 ; } ;\n"

"void operator &= ( void ) { x = x & 1 ; } ;\n"

"void operator |= ( void ) { x = x | 1 ; } ;\n"

"void operator ^= ( void ) { x = x ^ 1 ; } ;\n"

"void operator <<= ( void ) { x = x << 1 ; } ;\n"

"void operator >>= ( void ) { x = x >> 1 ; } ;";

ASSERT_EQUALS(expected, preprocess(code));

simplecpp::OutputList outputList;

code = "#define A +##x\n"

"A";

outputList.clear();

ASSERT_EQUALS("", preprocess(code, &outputList));

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'A', Invalid ## usage when expanding 'A': Combining '+' and 'x' yields an invalid token.\n", toString(outputList));

code = "#define A 2##=\n"