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

#define SIMPLECPP_WINDOWS

#define NOMINMAX

#endif

#include "simplecpp.h"

#include <algorithm>

#include <cassert>

#include <cctype>

#include <climits>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <exception>

#include <fstream> // IWYU pragma: keep

#include <iostream>

#include <limits>

#include <list>

#include <map>

#include <set>

#include <sstream> // IWYU pragma: keep

#include <stack>

#include <stdexcept>

#include <string>

#if __cplusplus >= 201103L

#include <unordered_map>

#endif

#include <utility>

#include <vector>

#ifdef SIMPLECPP_WINDOWS

#include <windows.h>

#undef ERROR

#endif

#if (__cplusplus < 201103L) && !defined(__APPLE__)

#define nullptr NULL

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

}

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

}

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

}

static bool startsWith(const std::string &str, const std::string &s)

{

return (str.size() >= s.size() && str.compare(0, s.size(), s) == 0);

}

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)

}

const std::string simplecpp::Location::emptyFileName;

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

virtual int get() = 0;

virtual int peek() = 0;

virtual void unget() = 0;

virtual bool good() = 0;

unsigned char readChar()

}

unsigned char 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;

};

class StdIStream : 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 std::string &filename, std::vector<std::string> &filenames, OutputList *outputList)

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

{

FileStream stream(filename);

readfile(stream,filename,outputList);

}

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

{

*this = other;

}

#if __cplusplus >= 201103L

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

{

*this = std::move(other);

}

#endif

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;

}

#if __cplusplus >= 201103L

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

{

if (this != &other) {

clear();

frontToken = other.frontToken;

other.frontToken = nullptr;

backToken = other.backToken;

other.backToken = nullptr;

files = other.files;

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

}

return *this;

}

#endif

void simplecpp::TokenList::clear()

{

backToken = nullptr;

while (frontToken) {

Token * const next = frontToken->next;

delete frontToken;

frontToken = next;

}

sizeOfType.clear();

}

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

{

if (!frontToken)

frontToken = tok;

else

backToken->next = tok;

tok->previous = backToken;

backToken = tok;

}

void simplecpp::TokenList::dump() const

{

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

}

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

{

std::ostringstream ret;

Location loc(files);

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 << " \"" << tok->location.file() << "\"\n";

loc = tok->location;

}

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

ret << '\n';

loc.line++;

}

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

ret << ' ';

ret << tok->str();

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

}

return ret.str();

}

static bool isNameChar(unsigned char ch)

{

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

}

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

}

static void portabilityBackslash(simplecpp::OutputList *outputList, const std::vector<std::string> &files, 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(files);

location.fileIndex = fileIndex(filename);

location.line = 1U;

location.col = 1U;

while (stream.good()) {

unsigned char ch = stream.readChar();

if (!stream.good())

break;

if (ch < ' ' && ch != '\t' && ch != '\n' && ch != '\r')

ch = ' ';

if (ch >= 0x80) {

if (outputList) {

simplecpp::Output err(files);

err.type = simplecpp::Output::UNHANDLED_CHAR_ERROR;

err.location = location;

std::ostringstream s;

s << static_cast<int>(ch);

err.msg = "The code contains unhandled character(s) (character code=" + s.str() + "). Neither unicode nor extended ascii is supported.";

outputList->push_back(err);

}

clear();

return;

}

if (ch == '\n') {

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

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

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

++multiline;

deleteToken(back());

} else {

location.line += multiline + 1;

multiline = 0U;

}

if (!multiline)

location.col = 1;

if (oldLastToken != cback()) {

oldLastToken = cback();

if (!isLastLinePreprocessor())

continue;

const std::string lastline(lastLine());

if (lastline == "# file %str%") {

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;

} else if (lastline == "# line %num%") {

const Token *numtok = cback();

while (numtok->comment)

numtok = numtok->previous;

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

} else if (lastline == "# %num% %str%" || lastline == "# line %num% %str%") {

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

}

// #endfile

else if (lastline == "# endfile" && !loc.empty()) {

location = loc.top();

loc.pop();

}

}

continue;

}

if (std::isspace(ch)) {

location.col++;

continue;

}

TokenString currentToken;

if (cback() && cback()->location.line == location.line && cback()->previous && cback()->previous->op == '#' && isLastLinePreprocessor() && (lastLine() == "# error" || lastLine() == "# warning")) {

char prev = ' ';

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

currentToken += ch;

prev = ch;

ch = stream.readChar();

}

stream.ungetChar();

push_back(new Token(currentToken, location));

location.adjust(currentToken);

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 != '\r' && ch != '\n') {

currentToken += ch;

ch = stream.readChar();

}

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

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

portabilityBackslash(outputList, files, location);

if (currentToken[currentToken.size() - 1U] == '\\') {

++multiline;

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

} else {

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

err.type = Output::SYNTAX_ERROR;

err.location = location;

err.msg = "Invalid newline in raw string delimiter.";

outputList->push_back(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(files);

err.type = Output::SYNTAX_ERROR;

err.location = location;

err.msg = "Raw string missing terminating delimiter.";

outputList->push_back(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)); // push string without newlines

else

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

if (newlines > 0 && isLastLinePreprocessor() && lastLine().compare(0,9,"# define ") == 0) {

multiline += newlines;

location.adjust(s);

} else {

location.adjust(currentToken);

}

continue;

}

else {

currentToken += ch;

}

if (*currentToken.begin() == '<' && isLastLinePreprocessor() && lastLine() == "# include") {

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

if (currentToken.size() < 2U)

return;

}

push_back(new Token(currentToken, location));

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

constFoldUnaryNotPosNeg(tok);

constFoldMulDivRem(tok);

constFoldAddSub(tok);

constFoldShift(tok);

constFoldComparison(tok);

constFoldBitwise(tok);

constFoldLogicalOp(tok);

constFoldQuestionOp(&tok);

// If there is no '(' we are done with the constant folding

if (tok->op != '(')

break;

if (!tok->next || !tok->next->next || tok->next->next->op != ')')

break;

tok = tok->next;

deleteToken(tok->previous);

deleteToken(tok->next);

}

}

static bool isFloatSuffix(const simplecpp::Token *tok)

}

void simplecpp::TokenList::combineOperators()

{

std::stack<bool> executableScope;

executableScope.push(false);

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

if (tok->op == '{') {

if (executableScope.top()) {

executableScope.push(true);

continue;

}

const Token *prev = tok->previous;

while (prev && prev->isOneOf(";{}()"))

prev = prev->previous;

executableScope.push(prev && prev->op == ')');

continue;

}

if (tok->op == '}') {

if (executableScope.size() > 1)

executableScope.pop();

continue;

}

if (tok->op == '.') {

// ellipsis ...

if (tok->next && tok->next->op == '.' && tok->next->location.col == (tok->location.col + 1) &&

tok->next->next && tok->next->next->op == '.' && tok->next->next->location.col == (tok->location.col + 2)) {

tok->setstr("...");

deleteToken(tok->next);

deleteToken(tok->next);

continue;

}

// float literals..

if (tok->previous && tok->previous->number && sameline(tok->previous, tok)) {

tok->setstr(tok->previous->str() + '.');

deleteToken(tok->previous);

if (isFloatSuffix(tok->next) || (tok->next && tok->next->startsWithOneOf("AaBbCcDdEeFfPp"))) {

tok->setstr(tok->str() + tok->next->str());

deleteToken(tok->next);

}

}

if (tok->next && tok->next->number) {

tok->setstr(tok->str() + tok->next->str());

deleteToken(tok->next);

}

}

// match: [0-9.]+E [+-] [0-9]+

const char lastChar = tok->str()[tok->str().size() - 1];

if (tok->number && !isOct(tok->str()) &&

((!isHex(tok->str()) && (lastChar == 'E' || lastChar == 'e')) ||

(isHex(tok->str()) && (lastChar == 'P' || lastChar == 'p'))) &&

tok->next && tok->next->isOneOf("+-") && tok->next->next && tok->next->next->number) {

tok->setstr(tok->str() + tok->next->op + tok->next->next->str());

deleteToken(tok->next);

deleteToken(tok->next);

}

if (tok->op == '\0' || !tok->next || tok->next->op == '\0')

continue;

if (!sameline(tok,tok->next))

continue;

if (tok->location.col + 1U != tok->next->location.col)

continue;

if (tok->next->op == '=' && tok->isOneOf("=!<>+-*/%&|^")) {

if (tok->op == '&' && !executableScope.top()) {

// don't combine &= if it is a anonymous reference parameter with default value:

// void f(x&=2)

int indentlevel = 0;

const Token *start = tok;

while (indentlevel >= 0 && start) {

if (start->op == ')')

++indentlevel;

else if (start->op == '(')

--indentlevel;

else if (start->isOneOf(";{}"))

break;

start = start->previous;

}

if (indentlevel == -1 && start) {

const Token * const ftok = start;

bool isFuncDecl = ftok->name;

while (isFuncDecl) {

if (!start->name && start->str() != "::" && start->op != '*' && start->op != '&')

isFuncDecl = false;

if (!start->previous)

break;

if (start->previous->isOneOf(";{}:"))

break;

start = start->previous;

}

isFuncDecl &= start != ftok && start->name;

if (isFuncDecl) {

// TODO: we could loop through the parameters here and check if they are correct.

continue;

}

}