/*

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

* Copyright (C) 2016-2023 simplecpp team

*/

#include "simplecpp.h"

#include <cctype>

#include <cstdlib>

#include <cstring>

#include <exception>

#include <iostream>

#include <sstream>

#include <stdexcept>

#include <string>

#include <utility>

#include <vector>

#ifndef SIMPLECPP_TEST_SOURCE_DIR

#error "SIMPLECPP_TEST_SOURCE_DIR is not defined."

#endif

#define STRINGIZE_(x) #x

#define STRINGIZE(x) STRINGIZE_(x)

static const std::string testSourceDir = SIMPLECPP_TEST_SOURCE_DIR;

static int numberOfFailedAssertions = 0;

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

#define ASSERT_THROW_EQUALS(stmt, e, expected) do { try { stmt; assertThrowFailed(__LINE__); } catch (const e& ex) { assertEquals((expected), (ex.what()), __LINE__); } } 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 test.cpp:" << line << std::endl;

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

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

}

return (expected == actual);

}

static int assertEquals(const long long &expected, const long long &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 {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, const std::string &file = std::string())

{

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

simplecpp::FileDataCache cache;

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

if (dui.removeComments)

tokens.removeComments();

simplecpp::TokenList tokens2(files);

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

simplecpp::cleanup(cache);

return tokens2.stringify();

}

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

{

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

}

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

{

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

}

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,";

break;

case simplecpp::Output::Type::FILE_NOT_FOUND:

ostr << "file_not_found,";

break;

case simplecpp::Output::Type::DUI_ERROR:

ostr << "dui_error,";

break;

}

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("\"test.c\" 1 0", preprocess("__FILE__ __LINE__ __COUNTER__", "test.c"));

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('AB', simplecpp::characterLiteralToLL("'AB'"));

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

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

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

// END Implementation-specific results

#endif

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\9'"), std::runtime_error, "invalid escape sequence");

// 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_EQUALS(simplecpp::characterLiteralToLL("u'\360\223\200\200'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\302\265'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\305\227'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\357\274\217'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\343\201\202'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\360\223\200\200'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\U11111111"), std::runtime_error, "code point too large");

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

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x89'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf4\x90\x80\x80'"), std::runtime_error, "code point too large");

// 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_EQUALS(simplecpp::characterLiteralToLL("U'\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80\x8f\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf\x8f\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0 '"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x8f '"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x8f\x8f '"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf8'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xff'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0\xaf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x80\xaf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x80\x80\xaf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc1\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x9f\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x8f\xbf\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x80\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x80\x80\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xed\xa0\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xed\xbf\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL(""), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("LU"), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL(";\n"), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8U"), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\n\n"), std::runtime_error, "raw single quotes and newlines not allowed in character literals");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("''&"), std::runtime_error, "raw single quotes and newlines not allowed in character literals");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L'\fff"), std::runtime_error, "multiple characters only supported in narrow character literals");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\\n"), std::runtime_error, "unexpected end of character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L'"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'a"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\555"), std::runtime_error, "numeric escape sequence too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'Ó"), std::runtime_error, "assumed UTF-8 encoded source, but character literal ends unexpectedly");

}

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"));

ASSERT_EQUALS("1.0_a . b", preprocess("1.0_a.b"));

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

ASSERT_EQUALS("bool x = d != 0. and b ;", preprocess("bool x = d != 0. and b;"));

}

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()

{

simplecpp::DUI dui;

dui.removeComments = true;

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

"}\n"

"void f() ABC\n";

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

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

"}\n"

"void f() ABC\n";

ASSERT_EQUALS("\n\nvoid f ( ) {", preprocess(code1, dui));

const char code2[] = "#define A 1// \\\r"

"\r"

"2\r"

"A\r";

ASSERT_EQUALS("\n\n2\n1", preprocess(code2, dui));

const char code3[] = "void f() {// \\ \n}\n";

ASSERT_EQUALS("void f ( ) {", preprocess(code3, dui));

const char code4[] = "void f() {// \\\\\\\t\t\n}\n";

ASSERT_EQUALS("void f ( ) {", preprocess(code4, dui));

const char code5[] = "void f() {// \\\\\\a\n}\n";

ASSERT_EQUALS("void f ( ) {\n}", preprocess(code5, dui));

const char code6[] = "void f() {// \\\n\n\n}\n";

ASSERT_EQUALS("void f ( ) {\n\n\n}", preprocess(code6, dui));

// #471 ensure there is newline in comment so that line-splicing can be detected by tools

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

}

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"));

}

#ifdef __CYGWIN__

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/"));

}

#endif

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()

{

simplecpp::DUI dui;

dui.removeComments = true;

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

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

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

}

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 define12()

{

const char code[] = "struct foo x = {\n"

" #define V 0\n"

" .x = V,\n"

"};\n";

ASSERT_EQUALS("struct foo x = {\n"

"# define V 0\n"

". x = V ,\n"

"} ;", readfile(code));

ASSERT_EQUALS("struct foo x = {\n"

"\n"

". x = 0 ,\n"

"} ;", preprocess(code));

}

static void define13()

{

const char code[] = "#define M 180.\n"

"extern void g();\n"

"void f(double d) {\n"

" if (d > M) {}\n"

"}\n";

ASSERT_EQUALS("\nextern void g ( ) ;\n"

"void f ( double d ) {\n"

"if ( d > 180. ) { }\n"

"}", 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_11a()

{

const char code[] = "#define A_B_C 0x1\n"

"#define A_ADDRESS 0x00001000U\n"

"#define A ((uint32_t ) A_ADDRESS)\n"

"#define CONCAT(x, y, z) x ## _ ## y ## _ ## z\n"

"#define TEST_MACRO CONCAT(A, B, C)\n"

"TEST_MACRO\n";

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

const char code2[] = "#define ADDER_S(a, b) a + b\n" // #374

"#define ADDER(x) ADDER_S(x)\n"

"#define ARGUMENTS 1, 2\n"

"#define RUN ADDER(ARGUMENTS)\n"

"void f() { RUN; }\n";

ASSERT_EQUALS("\n\n\n\nvoid f ( ) { 1 + 2 ; }", preprocess(code2));

}

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_define_19() // #292

{

const char code[] = "#define X 1,2,3\n"

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

"#define Bar Foo(X, 0)\n"

"Bar\n";

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

}

static void define_define_20() // #384 arg contains comma

{

const char code[] = "#define Z_IS_ENABLED1(config_macro) Z_IS_ENABLED2(_XXXX##config_macro)\n"

"#define _XXXX1 _YYYY,\n"

"#define Z_IS_ENABLED2(one_or_two_args) Z_IS_ENABLED3(one_or_two_args 1, 0)\n"

"#define Z_IS_ENABLED3(ignore_this, val, ...) val\n"

"#define IS_ENABLED(config_macro) Z_IS_ENABLED1(config_macro)\n"

"#define FEATURE 1\n"

"a = IS_ENABLED(FEATURE)\n";

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

}

static void define_define_21() // #397 DEBRACKET macro

{

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

"#define B(val) val\n"

"A((2))\n";

ASSERT_EQUALS("\n\n2", preprocess(code1));

const char code2[] = "#define x (2)\n"

"#define A B x\n"

"#define B(val) val\n"

"A\n";

ASSERT_EQUALS("\n\n\nB ( 2 )", preprocess(code2));

const char code3[] = "#define __GET_ARG2_DEBRACKET(ignore_this, val, ...) __DEBRACKET val\n"

"#define __DEBRACKET(...) __VA_ARGS__\n"

"#5 \"a.c\"\n"

"__GET_ARG2_DEBRACKET(432 (33), (B))\n";

ASSERT_EQUALS("\n#line 5 \"a.c\"\nB", preprocess(code3));

}

static void define_define_22() // #400 inner macro not expanded after hash hash

{

const char code[] = "#define FOO(a) CAT(DO, STUFF)(1,2)\n"

"#define DOSTUFF(a, b) CAT(3, 4)\n"

"#define CAT(a, b) a##b\n"

"FOO(1)\n";

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

}

static void define_define_23() // #403 crash (infinite recursion)

{

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

"#define C(x, y) C_(x, y)\n"

"#define X(func) C(Y, C(func, Z))\n"

"#define die X(die)\n"

"die(void);\n";

ASSERT_EQUALS("\n\n\n\nYdieZ ( void ) ;", 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_va_args_4() // cppcheck trac #9754

{

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

"A(1, 2)\n";

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

}

static void define_va_opt_1()

{

const char code[] = "#define p1(fmt, args...) printf(fmt __VA_OPT__(,) args)\n"

"p1(\"hello\");\n"

"p1(\"%s\", \"hello\");\n";

ASSERT_EQUALS("\nprintf ( \"hello\" ) ;\n"

"printf ( \"%s\" , \"hello\" ) ;",

preprocess(code));

}

static void define_va_opt_2()

{

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

"__VA_OPT__(\\\n"

"printf(__VA_ARGS__);\\\n"

")\n"

"#define err2(something, ...) __VA_OPT__(err(__VA_ARGS__))\n"

"err2(test)\n"

"err2(test, \"%d\", 2)\n";

ASSERT_EQUALS("\n\n\n\n\n\nprintf ( \"%d\" , 2 ) ;", preprocess(code));

}

static void define_va_opt_3()

{

// non-escaped newline without closing parenthesis

const char code1[] = "#define err(...) __VA_OPT__(printf( __VA_ARGS__);\n"

")\n"

"err()";

simplecpp::OutputList outputList;

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

ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define, In definition of 'err': Missing closing parenthesis for __VA_OPT__\n",

toString(outputList));