/*

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

* Copyright (C) 2016-2023 simplecpp team

*/

#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> // IWYU pragma: keep

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <exception>

#include <fstream>

#include <iostream>

#include <istream>

#include <limits>

#include <list>

#include <map>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <string>

#if __cplusplus >= 201103L

#ifdef SIMPLECPP_WINDOWS

#include <mutex>

#endif

#include <unordered_map>

#endif

#include <utility>

#include <vector>

#ifdef SIMPLECPP_WINDOWS

#include <windows.h>

#undef ERROR

#endif

#if __cplusplus >= 201103L

#define OVERRIDE override

#define EXPLICIT explicit

#else

#define OVERRIDE

#define EXPLICIT

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

}

// TODO: added an undercore since this conflicts with a function of the same name in utils.h from Cppcheck source when building Cppcheck with MSBuild

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

{

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

}

// TODO: added an undercore since this conflicts with a function of the same name in utils.h from Cppcheck source when building Cppcheck with MSBuild

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

{

// char literal patterns can include 'a', '\t', '\000', '\xff', 'abcd', and maybe ''

// This only checks for the surrounding '' but doesn't parse the content.

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

}

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

static const simplecpp::TokenString INNER_COMMA(",,");

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

{

// NOLINTNEXTLINE(misc-const-correctness) - false positive

std::ostringstream ostr;

ostr << t;

return ostr.str();

}

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

{

long long ret;

const bool hex = isHex(s);

const bool oct = isOct(s);

std::istringstream istr(hex ? s.substr(2) : oct ? s.substr(1) : s);

if (hex)

istr >> std::hex;

else if (oct)

istr >> std::oct;

istr >> ret;

return ret;

}

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

{

unsigned long long ret;

const bool hex = isHex(s);

const bool oct = isOct(s);

std::istringstream istr(hex ? s.substr(2) : oct ? s.substr(1) : s);

if (hex)

istr >> std::hex;

else if (oct)

istr >> std::oct;

istr >> ret;

return ret;

}

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)

{

return (tok->name &&

tok->str() == alt &&

tok->previous &&

tok->next &&

(tok->previous->number || tok->previous->name || tok->previous->op == ')') &&

(tok->next->number || tok->next->name || tok->next->op == '('));

}

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

{

return ((tok->name && tok->str() == alt) &&

(!tok->previous || tok->previous->op == '(') &&

(tok->next && (tok->next->name || tok->next->number)));

}

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

{

for (size_t pos = s.find(from); pos != std::string::npos; pos = s.find(from, pos + to.size()))

s.replace(pos, from.size(), to);

return s;

}

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;

}

// cppcheck-suppress noConstructor - we call init() in the inherited to initialize the private members

class simplecpp::TokenList::Stream {

public:

virtual ~Stream() {}

virtual int get() = 0;

virtual int peek() = 0;

virtual void unget() = 0;

virtual bool good() = 0;

unsigned char readChar()

{

unsigned char ch = static_cast<unsigned char>(get());

// For UTF-16 encoded files the BOM is 0xfeff/0xfffe. If the

// character is non-ASCII character then replace it with 0xff

if (isUtf16) {

const unsigned char ch2 = static_cast<unsigned char>(get());

const int ch16 = makeUtf16Char(ch, ch2);

ch = static_cast<unsigned char>(((ch16 >= 0x80) ? 0xff : ch16));

}

// Handling of newlines..

if (ch == '\r') {

ch = '\n';

int ch2 = get();

if (isUtf16) {

const int c2 = get();

ch2 = makeUtf16Char(ch2, c2);

}

if (ch2 != '\n')

ungetChar();

}

return ch;

}

unsigned char peekChar()

{

unsigned char ch = static_cast<unsigned char>(peek());

// For UTF-16 encoded files the BOM is 0xfeff/0xfffe. If the

// character is non-ASCII character then replace it with 0xff

if (isUtf16) {

(void)get();

const unsigned char ch2 = static_cast<unsigned char>(peek());

unget();

const int ch16 = makeUtf16Char(ch, ch2);

ch = static_cast<unsigned char>(((ch16 >= 0x80) ? 0xff : ch16));

}

// Handling of newlines..

if (ch == '\r')

ch = '\n';

return ch;

}

void ungetChar()

{

unget();

if (isUtf16)

unget();

}

protected:

void init() {

// initialize since we use peek() in getAndSkipBOM()

isUtf16 = false;

bom = getAndSkipBOM();

isUtf16 = (bom == 0xfeff || bom == 0xfffe);

}

private:

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

{

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

}

unsigned short getAndSkipBOM()

{

const int ch1 = peek();

// The UTF-16 BOM is 0xfffe or 0xfeff.

if (ch1 >= 0xfe) {

(void)get();

const unsigned short byte = (static_cast<unsigned char>(ch1) << 8);

if (peek() >= 0xfe)

return byte | static_cast<unsigned char>(get());

unget();

return 0;

}

// Skip UTF-8 BOM 0xefbbbf

if (ch1 == 0xef) {

(void)get();

if (peek() == 0xbb) {

(void)get();

if (peek() == 0xbf) {

(void)get();

return 0;

}

unget();

}

unget();

}

return 0;

}

unsigned short bom;

protected:

bool isUtf16;

};

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

public:

// cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members

EXPLICIT StdIStream(std::istream &istr)

: istr(istr)

{

assert(istr.good());

init();

}

virtual int get() OVERRIDE {

return istr.get();

}

virtual int peek() OVERRIDE {

return istr.peek();

}

virtual void unget() OVERRIDE {

istr.unget();

}

virtual bool good() OVERRIDE {

return istr.good();

}

private:

std::istream &istr;

};

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

public:

// cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members

StdCharBufStream(const unsigned char* str, std::size_t size)

: str(str)

, size(size)

, pos(0)

, lastStatus(0)

{

init();

}

virtual int get() OVERRIDE {

if (pos >= size)

return lastStatus = EOF;

return str[pos++];

}

virtual int peek() OVERRIDE {

if (pos >= size)

return lastStatus = EOF;

return str[pos];

}

virtual void unget() OVERRIDE {

--pos;

}

virtual bool good() OVERRIDE {

return lastStatus != EOF;

}

private:

const unsigned char *str;

const std::size_t size;

std::size_t pos;

int lastStatus;

};

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

public:

// cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members

EXPLICIT FileStream(const std::string &filename, std::vector<std::string> &files)

: file(fopen(filename.c_str(), "rb"))

, lastCh(0)

, lastStatus(0)

{

if (!file) {

files.push_back(filename);

throw simplecpp::Output(files, simplecpp::Output::FILE_NOT_FOUND, "File is missing: " + filename);

}

init();

}

~FileStream() OVERRIDE {

fclose(file);

file = nullptr;

}

virtual int get() OVERRIDE {

lastStatus = lastCh = fgetc(file);

return lastCh;

}

virtual int peek() OVERRIDE{

// keep lastCh intact

const int ch = fgetc(file);

unget_internal(ch);

return ch;

}

virtual void unget() OVERRIDE {

unget_internal(lastCh);

}

virtual bool good() OVERRIDE {

return lastStatus != EOF;

}

private:

void unget_internal(int ch) {

if (isUtf16) {

// TODO: use ungetc() as well

// UTF-16 has subsequent unget() calls

fseek(file, -1, SEEK_CUR);

}

else

ungetc(ch, file);

}

FileStream(const FileStream&);

FileStream &operator=(const FileStream&);

FILE *file;

int lastCh;

int lastStatus;

};

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)

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

{

StdCharBufStream stream(data, size);

readfile(stream,filename,outputList);

}

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

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

{

StdCharBufStream stream(reinterpret_cast<const unsigned char*>(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) // TODO handle extra type of errors

{

outputList->push_back(e);

}

}

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)

{

std::ostringstream ostr;

ostr << '\"';

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

const char c = str[i];

if (c == '\\' || c == '\"' || c == '\'')

ostr << '\\';

ostr << c;

}

ostr << '\"';

return ostr.str();

}

static void portabilityBackslash(simplecpp::OutputList *outputList, const std::vector<std::string> &files, const simplecpp::Location &location)

{

if (!outputList)

return;

simplecpp::Output err(files);

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

err.location = location;

err.msg = "Combination 'backslash space newline' is not portable.";

outputList->push_back(err);

}

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

{

return str == "u" || str == "U" || str == "L" || str == "u8" ||

str == "R" || str == "uR" || str == "UR" || str == "LR" || str == "u8R";

}

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 >= 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 (ch <= ' ') {

location.col++;

continue;

}

TokenString currentToken;

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

const Token* const llTok = lastLineTok();

if (llTok && llTok->op == '#' && llTok->next && (llTok->next->str() == "error" || llTok->next->str() == "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 ) {

const Token * const llTok = lastLineTok();

if (llTok && llTok->op == '#' && llTok->next && llTok->next->str() == "define" && 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));

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)

{

if (!tok || tok->str().size() != 1U)

return false;

const char c = std::tolower(tok->str()[0]);

return c == 'f' || c == 'l';

}

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