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

#define SIMPLECPP_WINDOWS

#define NOMINMAX

#endif

#include "simplecpp.h"

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <exception>

#include <fstream>

#include <iostream>

#include <limits>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <utility>

#ifdef SIMPLECPP_WINDOWS

#include <windows.h>

#undef ERROR

#undef TRUE

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

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

}

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

}

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

{

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

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) != 0);

}

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

{

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

}

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

{

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

}

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(NULL), backToken(NULL), files(filenames) {}

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

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

{

readfile(istr,filename,outputList);

}

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

{

*this = other;

}

simplecpp::TokenList::~TokenList()

{

clear();

}

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

{

if (this != &other) {

clear();

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

push_back(new Token(*tok));

sizeOfType = other.sizeOfType;

}

return *this;

}

void simplecpp::TokenList::clear()

{

backToken = NULL;

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)

}

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

}

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

}

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

}

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)

}

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 = NULL;

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

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

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

loc.push(location);

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

location.line = 1U;

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

loc.push(location);

location.line = std::atol(cback()->str.c_str());

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

loc.push(location);

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

location.line = std::atol(cback()->previous->str.c_str());

}

// #endfile

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

location = loc.top();

loc.pop();

}

}

continue;

}

if (std::isspace(ch)) {

location.col++;

continue;

}

TokenString currentToken;

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

istr.unget();

}

}

// 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, "*/"))

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

// C++11 raw string literal

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

std::string delim;

ch = readChar(istr,bom);

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

delim += ch;

ch = readChar(istr,bom);

}

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

// TODO report

return;

currentToken = '\"';

const std::string endOfRawString(')' + delim + '\"');

while (istr.good() && !endsWith(currentToken, endOfRawString))

currentToken += readChar(istr,bom);

if (!endsWith(currentToken, endOfRawString))

// TODO report

return;

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

back()->setstr(escapeString(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);

if (currentToken.size() < 2U)

// TODO report

return;

std::string s = currentToken;

std::string::size_type pos;

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

s.erase(pos,1);

}

push_back(new Token(s, location)); // push string without newlines

location.adjust(currentToken);

continue;

}

else {

currentToken += ch;

}

if (currentToken == "<") {

if ((lastLine() == "# include") || (lastLine() == (std::string("# define ") + lastTokenInLine()))) {

currentToken = readUntil(istr, 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()

{

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

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

if (tok->previous && tok->previous->op == '.')

continue;

if (tok->next && tok->next->op == '.')

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("Ee"))) {

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 && !isHex(tok->str) && (lastChar == 'E' || lastChar == 'e') && 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("=!<>+-*/%&|^")) {

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

}

}

void simplecpp::TokenList::constFoldShift(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->str == "<<")

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

else if (tok->str == ">>")

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

else

continue;

tok = tok->previous;

tok->setstr(toString(result));

deleteToken(tok->next);

deleteToken(tok->next);

}

}

static const std::string NOTEQ("not_eq");

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

{

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

if (isAlternativeBinaryOp(tok,NOTEQ))

tok->setstr("!=");

if (!tok->startsWithOneOf("<>=!"))

continue;

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

continue;

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

continue;

int result;

if (tok->str == "==")

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

else if (tok->str == "!=")

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

else if (tok->str == ">")

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

else if (tok->str == ">=")

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

else if (tok->str == "<")

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

else if (tok->str == "<=")

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

else

continue;

tok = tok->previous;

tok->setstr(toString(result));

deleteToken(tok->next);

deleteToken(tok->next);

}

}

static const std::string BITAND("bitand");

static const std::string BITOR("bitor");

static const std::string XOR("xor");

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

{

Token * const tok1 = tok;

for (const char *op = "&^|"; *op; op++) {

const std::string* altop;

if (*op == '&')

altop = &BITAND;

else if (*op == '|')

altop = &BITOR;

else

altop = &XOR;

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

if (tok->op != *op && !isAlternativeBinaryOp(tok, *altop))

continue;

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

continue;

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

continue;

long long result;

if (*op == '&')

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

else if (*op == '^')

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

else /*if (*op == '|')*/

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

tok = tok->previous;

tok->setstr(toString(result));

deleteToken(tok->next);

deleteToken(tok->next);

}

}

}

static const std::string AND("and");

static const std::string OR("or");

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

{

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

if (tok->name) {

if (isAlternativeBinaryOp(tok,AND))

tok->setstr("&&");

else if (isAlternativeBinaryOp(tok,OR))

tok->setstr("||");

}

if (tok->str != "&&" && tok->str != "||")

continue;

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

continue;

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

continue;

int result;

if (tok->str == "||")

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

else /*if (tok->str == "&&")*/

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

tok = tok->previous;

tok->setstr(toString(result));

deleteToken(tok->next);

deleteToken(tok->next);

}

}

void simplecpp::TokenList::constFoldQuestionOp(Token **tok1)

{

bool gotoTok1 = false;

for (Token *tok = *tok1; tok && tok->op != ')'; tok = gotoTok1 ? *tok1 : tok->next) {

gotoTok1 = false;

if (tok->str != "?")

continue;

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

throw std::runtime_error("invalid expression");

if (!tok->previous->number)

continue;

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

continue;

Token * const condTok = tok->previous;

Token * const trueTok = tok->next;

Token * const falseTok = trueTok->next->next;

if (!falseTok)

throw std::runtime_error("invalid expression");

if (condTok == *tok1)

*tok1 = (condTok->str != "0" ? trueTok : falseTok);

deleteToken(condTok->next); // ?

deleteToken(trueTok->next); // :

deleteToken(condTok->str == "0" ? trueTok : falseTok);

deleteToken(condTok);

gotoTok1 = true;

}

}

void simplecpp::TokenList::removeComments()

{

Token *tok = frontToken;

while (tok) {

Token *tok1 = tok;

tok = tok->next;

if (tok1->comment)

deleteToken(tok1);

}

}

std::string simplecpp::TokenList::readUntil(std::istream &istr, const Location &location, const char start, const char end, OutputList *outputList)

{

std::string ret;

ret += start;

bool backslash = false;

char ch = 0;

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

ch = (unsigned char)istr.get();

if (backslash && ch == '\n') {

ch = 0;

backslash = false;

continue;

}

backslash = false;

ret += ch;

if (ch == '\\') {

const char next = (unsigned char)istr.get();

if (next == '\r' || next == '\n') {

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

backslash = (next == '\r');

}

ret += next;

}

}

if (!istr.good() || ch != end) {

clear();

if (outputList) {

Output err(files);

err.type = Output::SYNTAX_ERROR;

err.location = location;

err.msg = std::string("No pair for character (") + start + "). Can't process file. File is either invalid or unicode, which is currently not supported.";

outputList->push_back(err);

}

return "";

}

return ret;