#if defined(_WIN32)

# ifndef _WIN32_WINNT

# define _WIN32_WINNT 0x0602

# endif

# ifndef NOMINMAX

# define NOMINMAX

# endif

# ifndef WIN32_LEAN_AND_MEAN

# define WIN32_LEAN_AND_MEAN

# endif

# include <windows.h>

# undef ERROR

#endif

#include "simplecpp.h"

#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)

# define SIMPLECPP_WINDOWS

#endif

#include <algorithm>

#include <cassert>

#include <cctype>

#include <climits>

#include <cstddef> // IWYU pragma: keep

#include <cstdint>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <fstream>

#include <iostream>

#include <istream>

#include <limits>

#include <list>

#include <map>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <string>

#ifdef SIMPLECPP_WINDOWS

# include <mutex>

#endif

#include <unordered_map>

#include <utility>

#include <vector>

#ifdef _WIN32

# include <direct.h>

#else

# include <sys/stat.h>

#endif

#if __cplusplus >= 201402L

#define SIMPLECPP_PROPAGATE_CONST_GET(t) (t).get()

#else

#define SIMPLECPP_PROPAGATE_CONST_GET(t) (t)

#endif

static bool isHex(const std::string &s)

{

return s.size()>2 && (s.compare(0,2,"0x")==0 || s.compare(0,2,"0X")==0);

}

static bool isOct(const std::string &s)

{

return s.size()>1 && (s[0]=='0') && (s[1] >= '0') && (s[1] < '8');

}

static bool isStringLiteral(const std::string &s)

{

return s.size() > 1 && (s[0]=='\"') && (*s.rbegin()=='\"');

}

static bool isCharLiteral(const std::string &s)

}

static const simplecpp::TokenString DEFINE("define");

static const simplecpp::TokenString UNDEF("undef");

static const simplecpp::TokenString INCLUDE("include");

static const simplecpp::TokenString ERROR("error");

static const simplecpp::TokenString WARNING("warning");

static const simplecpp::TokenString IF("if");

static const simplecpp::TokenString IFDEF("ifdef");

static const simplecpp::TokenString IFNDEF("ifndef");

static const simplecpp::TokenString DEFINED("defined");

static const simplecpp::TokenString ELSE("else");

static const simplecpp::TokenString ELIF("elif");

static const simplecpp::TokenString ENDIF("endif");

static const simplecpp::TokenString PRAGMA("pragma");

static const simplecpp::TokenString ONCE("once");

static const simplecpp::TokenString HAS_INCLUDE("__has_include");

template<class T> static std::string toString(T t)

}

#ifdef SIMPLECPP_DEBUG_MACRO_EXPANSION

static std::string locstring(const simplecpp::Location &loc)

}

#endif

static long long stringToLL(const std::string &s)

}

static unsigned long long stringToULL(const std::string &s)

}

static bool endsWith(const std::string &s, const std::string &e)

{

return (s.size() >= e.size()) && std::equal(e.rbegin(), e.rend(), s.rbegin());

}

static bool sameline(const simplecpp::Token *tok1, const simplecpp::Token *tok2)

{

return tok1 && tok2 && tok1->location.sameline(tok2->location);

}

static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string &alt)

}

static bool isAlternativeUnaryOp(const simplecpp::Token *tok, const std::string &alt)

}

static std::string replaceAll(std::string s, const std::string& from, const std::string& to)

}

void simplecpp::Location::adjust(const std::string &str)

{

if (strpbrk(str.c_str(), "\r\n") == nullptr) {

col += str.size();

return;

}

for (std::size_t i = 0U; i < str.size(); ++i) {

col++;

if (str[i] == '\n' || str[i] == '\r') {

col = 1;

line++;

if (str[i] == '\r' && (i+1)<str.size() && str[i+1]=='\n')

++i;

}

}

}

bool simplecpp::Token::isOneOf(const char ops[]) const

{

return (op != '\0') && (std::strchr(ops, op) != nullptr);

}

bool simplecpp::Token::startsWithOneOf(const char c[]) const

{

return std::strchr(c, string[0]) != nullptr;

}

bool simplecpp::Token::endsWithOneOf(const char c[]) const

{

return std::strchr(c, string[string.size() - 1U]) != nullptr;

}

void simplecpp::Token::printAll() const

{

const Token *tok = this;

while (tok->previous)

tok = tok->previous;

for (; tok; tok = tok->next) {

if (tok->previous) {

std::cout << (sameline(tok, tok->previous) ? ' ' : '\n');

}

std::cout << tok->str();

}

std::cout << std::endl;

}

void simplecpp::Token::printOut() const

{

for (const Token *tok = this; tok; tok = tok->next) {

if (tok != this) {

std::cout << (sameline(tok, tok->previous) ? ' ' : '\n');

}

std::cout << tok->str();

}

std::cout << std::endl;

}

class simplecpp::TokenList::Stream {

virtual ~Stream() = default;

virtual int get() = 0;

virtual int peek() = 0;

virtual void unget() = 0;

virtual bool good() = 0;

unsigned char readChar() {

}

int peekChar() {

}

void ungetChar() {

}

void init() {

}

inline int makeUtf16Char(const unsigned char ch, const unsigned char ch2) const {

return (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);

}

unsigned short getAndSkipBOM() {

}

unsigned short bom;

bool isUtf16;

};

namespace {

class StdIStream : public simplecpp::TokenList::Stream {

};

class StdCharBufStream : public simplecpp::TokenList::Stream {

};

class FileStream : public simplecpp::TokenList::Stream {

};

}

simplecpp::TokenList::TokenList(std::vector<std::string> &filenames) : frontToken(nullptr), backToken(nullptr), files(filenames) {}

simplecpp::TokenList::TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList)

: frontToken(nullptr), backToken(nullptr), files(filenames)

{

StdIStream stream(istr);

readfile(stream,filename,outputList);

}

simplecpp::TokenList::TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList, int /*unused*/)

: frontToken(nullptr), backToken(nullptr), files(filenames)

{

StdCharBufStream stream(data, size);

readfile(stream,filename,outputList);

}

simplecpp::TokenList::TokenList(const std::string &filename, std::vector<std::string> &filenames, OutputList *outputList)

: frontToken(nullptr), backToken(nullptr), files(filenames)

{

try {

FileStream stream(filename, filenames);

readfile(stream,filename,outputList);

} catch (const simplecpp::Output & e) {

outputList->emplace_back(e);

}

}

simplecpp::TokenList::TokenList(const TokenList &other) : frontToken(nullptr), backToken(nullptr), files(other.files)

{

*this = other;

}

simplecpp::TokenList::TokenList(TokenList &&other) : frontToken(nullptr), backToken(nullptr), files(other.files)

{

*this = std::move(other);

}

simplecpp::TokenList::~TokenList()

{

clear();

}

simplecpp::TokenList &simplecpp::TokenList::operator=(const TokenList &other)

{

if (this != &other) {

clear();

files = other.files;

for (const Token *tok = other.cfront(); tok; tok = tok->next)

push_back(new Token(*tok));

sizeOfType = other.sizeOfType;

}

return *this;

}

simplecpp::TokenList &simplecpp::TokenList::operator=(TokenList &&other)

{

if (this != &other) {

clear();

frontToken = SIMPLECPP_PROPAGATE_CONST_GET(other.frontToken);

other.frontToken = nullptr;

backToken = SIMPLECPP_PROPAGATE_CONST_GET(other.backToken);

other.backToken = nullptr;

files = other.files;

sizeOfType = std::move(other.sizeOfType);

}

return *this;

}

void simplecpp::TokenList::clear()

{

backToken = nullptr;

while (frontToken) {

// NOLINTNEXTLINE(misc-const-correctness) - FP

Token * const next = frontToken->next;

delete SIMPLECPP_PROPAGATE_CONST_GET(frontToken);

frontToken = next;

}

sizeOfType.clear();

}

void simplecpp::TokenList::push_back(Token *tok)

{

if (!frontToken)

frontToken = tok;

else

backToken->next = tok;

tok->previous = SIMPLECPP_PROPAGATE_CONST_GET(backToken);

backToken = tok;

}

void simplecpp::TokenList::dump(bool linenrs) const

{

std::cout << stringify(linenrs) << std::endl;

}

std::string simplecpp::TokenList::stringify(bool linenrs) const

{

std::ostringstream ret;

Location loc;

loc.line = 1;

bool filechg = true;

for (const Token *tok = cfront(); tok; tok = tok->next) {

if (tok->location.line < loc.line || tok->location.fileIndex != loc.fileIndex) {

ret << "\n#line " << tok->location.line << " \"" << file(tok->location) << "\"\n";

loc = tok->location;

filechg = true;

}

if (linenrs && filechg) {

ret << loc.line << ": ";

filechg = false;

}

while (tok->location.line > loc.line) {

ret << '\n';

loc.line++;

if (linenrs)

ret << loc.line << ": ";

}

if (sameline(tok->previous, tok))

ret << ' ';

ret << tok->str();

loc.adjust(tok->str());

}

return ret.str();

}

static bool isNameChar(int ch)

{

return std::isalnum(ch) || ch == '_' || ch == '$';

}

static std::string escapeString(const std::string &str)

}

static void portabilityBackslash(simplecpp::OutputList *outputList, const simplecpp::Location &location)

}

static bool isStringLiteralPrefix(const std::string &str)

}

void simplecpp::TokenList::lineDirective(unsigned int fileIndex_, unsigned int line, Location &location)

{

if (fileIndex_ != location.fileIndex || line >= location.line) {

location.fileIndex = fileIndex_;

location.line = line;

return;

}

if (line + 2 >= location.line) {

location.line = line;

while (cback()->op != '#')

deleteToken(back());

deleteToken(back());

return;

}

}

static const std::string COMMENT_END("*/");

void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename, OutputList *outputList)

{

std::stack<simplecpp::Location> loc;

unsigned int multiline = 0U;

const Token *oldLastToken = nullptr;

Location location(fileIndex(filename), 1, 1);

while (stream.good()) {

unsigned char ch = stream.readChar();

if (!stream.good())

break;

if (ch >= 0x80) {

if (outputList) {

simplecpp::Output err{

simplecpp::Output::UNHANDLED_CHAR_ERROR,

location,

"The code contains unhandled character(s) (character code=" + std::to_string(static_cast<int>(ch)) + "). Neither unicode nor extended ascii is supported."

};

outputList->emplace_back(std::move(err));

}

clear();

return;

}

if (ch == '\n') {

if (cback() && cback()->op == '\\') {

if (location.col > cback()->location.col + 1U)

portabilityBackslash(outputList, cback()->location);

++multiline;

deleteToken(back());

} else {

location.line += multiline + 1;

multiline = 0U;

}

if (!multiline)

location.col = 1;

if (oldLastToken != cback()) {

oldLastToken = cback();

const Token * const llTok = isLastLinePreprocessor();

if (!llTok)

continue;

const Token * const llNextToken = llTok->next;

if (!llTok->next)

continue;

if (llNextToken->next) {

// #file "file.c"

if (llNextToken->str() == "file" &&

llNextToken->next->str()[0] == '\"')

{

const Token *strtok = cback();

while (strtok->comment)

strtok = strtok->previous;

loc.push(location);

location.fileIndex = fileIndex(strtok->str().substr(1U, strtok->str().size() - 2U));

location.line = 1U;

}

// TODO: add support for "# 3"

// #3 "file.c"

// #line 3 "file.c"

else if ((llNextToken->number &&

llNextToken->next->str()[0] == '\"') ||

(llNextToken->str() == "line" &&

llNextToken->next->number &&

llNextToken->next->next &&

llNextToken->next->next->str()[0] == '\"'))

{

const Token *strtok = cback();

while (strtok->comment)

strtok = strtok->previous;

const Token *numtok = strtok->previous;

while (numtok->comment)

numtok = numtok->previous;

lineDirective(fileIndex(replaceAll(strtok->str().substr(1U, strtok->str().size() - 2U),"\\\\","\\")),

std::atol(numtok->str().c_str()), location);

}

// #line 3

else if (llNextToken->str() == "line" &&

llNextToken->next->number)

{

const Token *numtok = cback();

while (numtok->comment)

numtok = numtok->previous;

lineDirective(location.fileIndex, std::atol(numtok->str().c_str()), location);

}

}

// #endfile

else if (llNextToken->str() == "endfile" && !loc.empty())

{

location = loc.top();

loc.pop();

}

}

continue;

}

if (ch <= ' ') {

location.col++;

continue;

}

TokenString currentToken;

if (cback() && cback()->location.line == location.line && cback()->previous && cback()->previous->op == '#') {

const Token* const ppTok = cback()->previous;

if (ppTok->next && (ppTok->next->str() == "error" || ppTok->next->str() == "warning")) {

char prev = ' ';

while (stream.good() && (prev == '\\' || (ch != '\r' && ch != '\n'))) {

currentToken += ch;

prev = ch;

ch = stream.readChar();

}

stream.ungetChar();

std::string::size_type pos = 0;

unsigned int spliced = 0;

while ((pos = currentToken.find('\\', pos)) != std::string::npos) {

if (pos + 1 < currentToken.size() && currentToken[pos + 1] == '\n') {

currentToken.erase(pos, 2);

++spliced;

} else {

++pos;

}

}

if (!currentToken.empty()) {

push_back(new Token(currentToken, location));

location.adjust(currentToken);

}

location.line += spliced;

continue;

}

}

// number or name

if (isNameChar(ch)) {

const bool num = !!std::isdigit(ch);

while (stream.good() && isNameChar(ch)) {

currentToken += ch;

ch = stream.readChar();

if (num && ch=='\'' && isNameChar(stream.peekChar()))

ch = stream.readChar();

}

stream.ungetChar();

}

// comment

else if (ch == '/' && stream.peekChar() == '/') {

while (stream.good() && ch != '\n') {

currentToken += ch;

ch = stream.readChar();

if (ch == '\\') {

TokenString tmp;

char tmp_ch = ch;

while ((stream.good()) && (tmp_ch == '\\' || tmp_ch == ' ' || tmp_ch == '\t')) {

tmp += tmp_ch;

tmp_ch = stream.readChar();

}

if (!stream.good()) {

break;

}

if (tmp_ch != '\n') {

currentToken += tmp;

} else {

const TokenString check_portability = currentToken + tmp;

const std::string::size_type pos = check_portability.find_last_not_of(" \t");

if (pos < check_portability.size() - 1U && check_portability[pos] == '\\')

portabilityBackslash(outputList, location);

++multiline;

tmp_ch = stream.readChar();

currentToken += '\n';

}

ch = tmp_ch;

}

}

if (ch == '\n') {

stream.ungetChar();

}

}

// comment

else if (ch == '/' && stream.peekChar() == '*') {

currentToken = "/*";

(void)stream.readChar();

ch = stream.readChar();

while (stream.good()) {

currentToken += ch;

if (currentToken.size() >= 4U && endsWith(currentToken, COMMENT_END))

break;

ch = stream.readChar();

}

// multiline..

std::string::size_type pos = 0;

while ((pos = currentToken.find("\\\n",pos)) != std::string::npos) {

currentToken.erase(pos,2);

++multiline;

}

if (multiline || isLastLinePreprocessor()) {

pos = 0;

while ((pos = currentToken.find('\n',pos)) != std::string::npos) {

currentToken.erase(pos,1);

++multiline;

}

}

}

// string / char literal

else if (ch == '\"' || ch == '\'') {

std::string prefix;

if (cback() && cback()->name && isStringLiteralPrefix(cback()->str()) &&

((cback()->location.col + cback()->str().size()) == location.col) &&

(cback()->location.line == location.line)) {

prefix = cback()->str();

}

// C++11 raw string literal

if (ch == '\"' && !prefix.empty() && *cback()->str().rbegin() == 'R') {

std::string delim;

currentToken = ch;

prefix.resize(prefix.size() - 1);

ch = stream.readChar();

while (stream.good() && ch != '(' && ch != '\n') {

delim += ch;

ch = stream.readChar();

}

if (!stream.good() || ch == '\n') {

if (outputList) {

Output err{

Output::SYNTAX_ERROR,

location,

"Invalid newline in raw string delimiter."

};

outputList->emplace_back(std::move(err));

}

return;

}

const std::string endOfRawString(')' + delim + currentToken);

while (stream.good() && (!endsWith(currentToken, endOfRawString) || currentToken.size() <= 1))

currentToken += stream.readChar();

if (!endsWith(currentToken, endOfRawString)) {

if (outputList) {

Output err{

Output::SYNTAX_ERROR,

location,

"Raw string missing terminating delimiter."

};

outputList->emplace_back(std::move(err));

}

return;

}

currentToken.erase(currentToken.size() - endOfRawString.size(), endOfRawString.size() - 1U);

currentToken = escapeString(currentToken);

currentToken.insert(0, prefix);

back()->setstr(currentToken);

location.adjust(currentToken);

if (currentToken.find_first_of("\r\n") == std::string::npos)

location.col += 2 + (2 * delim.size());

else

location.col += 1 + delim.size();

continue;

}

currentToken = readUntil(stream,location,ch,ch,outputList);

if (currentToken.size() < 2U)

// Error is reported by readUntil()

return;

std::string s = currentToken;

std::string::size_type pos;

int newlines = 0;

while ((pos = s.find_first_of("\r\n")) != std::string::npos) {

s.erase(pos,1);

newlines++;

}

if (prefix.empty())

push_back(new Token(s, location, !!std::isspace(stream.peekChar()))); // push string without newlines

else

back()->setstr(prefix + s);

if (newlines > 0) {

const Token * const llTok = lastLineTok();

if (llTok && llTok->op == '#' && llTok->next && (llTok->next->str() == "define" || llTok->next->str() == "pragma") && llTok->next->next) {

multiline += newlines;

location.adjust(s);

continue;

}

}

location.adjust(currentToken);

continue;

}

else {

currentToken += ch;

}

if (*currentToken.begin() == '<') {

const Token * const llTok = lastLineTok();

if (llTok && llTok->op == '#' && llTok->next && llTok->next->str() == "include") {

currentToken = readUntil(stream, location, '<', '>', outputList);

if (currentToken.size() < 2U)

return;

}

}

push_back(new Token(currentToken, location, !!std::isspace(stream.peekChar())));

if (multiline)

location.col += currentToken.size();

else

location.adjust(currentToken);

}

combineOperators();

}

void simplecpp::TokenList::constFold()

{

while (cfront()) {

// goto last '('

Token *tok = back();

while (tok && tok->op != '(')

tok = tok->previous;

// no '(', goto first token

if (!tok)

tok = front();

// Constant fold expression