/*

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

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

*

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

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

* License as published by the Free Software Foundation, either

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

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

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

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

*/

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

#define SIMPLECPP_WINDOWS

#define NOMINMAX

#endif

#include "simplecpp.h"

#include <algorithm>

#include <climits>

#include <cstring>

#include <ctime>

#include <exception>

#include <fstream>

#include <iostream>

#include <limits>

#include <sstream>

#include <stack>

#include <stdexcept>

#if __cplusplus >= 201103L

#include <unordered_map>

#endif

#include <utility>

#ifdef SIMPLECPP_WINDOWS

#include <windows.h>

#undef ERROR

#undef TRUE

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

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

{

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 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() && s.compare(s.size() - e.size(), e.size(), e) == 0);

}

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;

}

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)

{

readfile(istr,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) : TokenList(other)

{

*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 *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 unsigned char readChar(std::istream &istr, unsigned int bom)

{

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

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

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

if (bom == 0xfeff || bom == 0xfffe) {

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

const int ch16 = (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);

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

}

// Handling of newlines..

if (ch == '\r') {

ch = '\n';

if (bom == 0 && static_cast<char>(istr.peek()) == '\n')

(void)istr.get();

else if (bom == 0xfeff || bom == 0xfffe) {

int c1 = istr.get();

int c2 = istr.get();

int ch16 = (bom == 0xfeff) ? (c1<<8 | c2) : (c2<<8 | c1);

if (ch16 != '\n') {

istr.unget();

istr.unget();

}

}

}

return ch;

}

static unsigned char peekChar(std::istream &istr, unsigned int bom)

{

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

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

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

if (bom == 0xfeff || bom == 0xfffe) {

(void)istr.get();

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

istr.unget();

const int ch16 = (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);

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

}

// Handling of newlines..

if (ch == '\r')

ch = '\n';

return ch;

}

static void ungetChar(std::istream &istr, unsigned int bom)

{

istr.unget();

if (bom == 0xfeff || bom == 0xfffe)

istr.unget();

}

static unsigned short getAndSkipBOM(std::istream &istr)

{

const int ch1 = istr.peek();

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

if (ch1 >= 0xfe) {

unsigned short bom = (static_cast<unsigned char>(istr.get()) << 8);

if (istr.peek() >= 0xfe)

return bom | static_cast<unsigned char>(istr.get());

istr.unget();

return 0;

}

// Skip UTF-8 BOM 0xefbbbf

if (ch1 == 0xef) {

(void)istr.get();

if (istr.get() == 0xbb && istr.peek() == 0xbf) {

(void)istr.get();

} else {

istr.unget();

istr.unget();

}

}

return 0;

}

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

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(std::istream &istr, const std::string &filename, OutputList *outputList)

{

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

unsigned int multiline = 0U;

const Token *oldLastToken = nullptr;

const unsigned short bom = getAndSkipBOM(istr);

Location location(files);

location.fileIndex = fileIndex(filename);

location.line = 1U;

location.col = 1U;

while (istr.good()) {

unsigned char ch = readChar(istr,bom);

if (!istr.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 == '#' && (lastLine() == "# error" || lastLine() == "# warning")) {

char prev = ' ';

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

currentToken += ch;

prev = ch;

ch = readChar(istr, bom);

}

ungetChar(istr, bom);

push_back(new Token(currentToken, location));

location.adjust(currentToken);

continue;

}

// number or name

if (isNameChar(ch)) {

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

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

currentToken += ch;

ch = readChar(istr,bom);

if (num && ch=='\'' && isNameChar(peekChar(istr,bom)))

ch = readChar(istr,bom);

}

ungetChar(istr,bom);

}

// comment

else if (ch == '/' && peekChar(istr,bom) == '/') {

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

currentToken += ch;

ch = readChar(istr, bom);

}

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 {

ungetChar(istr, bom);

}

}

// comment

else if (ch == '/' && peekChar(istr,bom) == '*') {

currentToken = "/*";

(void)readChar(istr,bom);

ch = readChar(istr,bom);

while (istr.good()) {

currentToken += ch;

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

break;

ch = readChar(istr,bom);

}

// multiline..

std::string::size_type pos = 0;

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

currentToken.erase(pos,2);

++multiline;

}

if (multiline || startsWith(lastLine(10),"# ")) {

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 = readChar(istr,bom);

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

delim += ch;

ch = readChar(istr,bom);

}

if (!istr.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 (istr.good() && !(endsWith(currentToken, endOfRawString) && currentToken.size() > 1))

currentToken += readChar(istr,bom);

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(istr,location,ch,ch,outputList,bom);

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 && lastLine().compare(0,9,"# define ") == 0) {

multiline += newlines;

location.adjust(s);

} else {

location.adjust(currentToken);

}

continue;

}

else {

currentToken += ch;

}

if (currentToken == "<" && lastLine() == "# include") {

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

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

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

deleteToken(tok->next);

deleteToken(tok->next);

continue;

}

// float literals..

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

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

}

}

}

tok->setstr(tok->str() + "=");

deleteToken(tok->next);

} else if ((tok->op == '|' || tok->op == '&') && tok->op == tok->next->op) {

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

deleteToken(tok->next);

} else if (tok->op == ':' && tok->next->op == ':') {

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

deleteToken(tok->next);

} else if (tok->op == '-' && tok->next->op == '>') {

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

deleteToken(tok->next);

} else if ((tok->op == '<' || tok->op == '>') && tok->op == tok->next->op) {

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

deleteToken(tok->next);

if (tok->next && tok->next->op == '=' && tok->next->next && tok->next->next->op != '=') {

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

deleteToken(tok->next);

}

} else if ((tok->op == '+' || tok->op == '-') && tok->op == tok->next->op) {

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

continue;

if (tok->previous && tok->previous->number)

continue;

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

continue;

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

deleteToken(tok->next);

}

}

}

static const std::string COMPL("compl");

static const std::string NOT("not");

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

{

for (; tok && tok->op != ')'; tok = tok->next) {

// "not" might be !

if (isAlternativeUnaryOp(tok, NOT))

tok->op = '!';

// "compl" might be ~

else if (isAlternativeUnaryOp(tok, COMPL))

tok->op = '~';

if (tok->op == '!' && tok->next && tok->next->number) {

tok->setstr(tok->next->str() == "0" ? "1" : "0");

deleteToken(tok->next);

} else if (tok->op == '~' && tok->next && tok->next->number) {

tok->setstr(toString(~stringToLL(tok->next->str())));

deleteToken(tok->next);

} else {

if (tok->previous && (tok->previous->number || tok->previous->name))

continue;

if (!tok->next || !tok->next->number)

continue;

switch (tok->op) {

case '+':

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

deleteToken(tok->next);

break;

case '-':

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

deleteToken(tok->next);

break;

}

}

}

}

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

{

for (; tok && tok->op != ')'; tok = tok->next) {

if (!tok->previous || !tok->previous->number)

continue;

if (!tok->next || !tok->next->number)

continue;

long long result;

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

result = (stringToLL(tok->previous->str()) * stringToLL(tok->next->str()));

else if (tok->op == '/' || tok->op == '%') {

long long rhs = stringToLL(tok->next->str());

if (rhs == 0)

throw std::overflow_error("division/modulo by zero");

long long lhs = stringToLL(tok->previous->str());

if (rhs == -1 && lhs == std::numeric_limits<long long>::min())

throw std::overflow_error("division overflow");

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

result = (lhs / rhs);

else

result = (lhs % rhs);

} else

continue;

tok = tok->previous;

tok->setstr(toString(result));

deleteToken(tok->next);

deleteToken(tok->next);

}

}

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

{

for (; tok && tok->op != ')'; tok = tok->next) {

if (!tok->previous || !tok->previous->number)

continue;

if (!tok->next || !tok->next->number)

continue;

long long result;

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

result = stringToLL(tok->previous->str()) + stringToLL(tok->next->str());

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

result = stringToLL(tok->previous->str()) - stringToLL(tok->next->str());

else

continue;

tok = tok->previous;

tok->setstr(toString(result));

deleteToken(tok->next);

deleteToken(tok->next);

}