/*

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

* Copyright (C) 2016 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/>.

*/

#include "simplecpp.h"

#include <algorithm>

#include <cctype>

#include <limits>

#include <list>

#include <map>

#include <set>

#include <stdexcept>

#include <vector>

#include <cstring>

#include <cstdlib> // strtoll, etc

#include <sstream>

#include <fstream>

#include <iostream>

#include <stack>

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

#include <windows.h>

#undef min

#undef max

#undef ERROR

#undef TRUE

#define SIMPLECPP_WINDOWS

#endif

namespace {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::ostringstream ostr;

ostr << t;

return ostr.str();

}

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

{

long long ret;

bool hex = (s.compare(0, 2, "0x") == 0);

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

if (hex)

istr >> std::hex;

istr >> ret;

return ret;

}

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

{

unsigned long long ret;

bool hex = (s.compare(0, 2, "0x") == 0);

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

if (hex)

istr >> std::hex;

istr >> ret;

return ret;

}

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

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

}

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

}

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

}

}

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

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 (const Token *tok = this; 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();

}

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

if (this == &other)

return;

clear();

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

push_back(new Token(*tok));

sizeOfType = other.sizeOfType;

}

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)

{

unsigned char ch = (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 = (unsigned char)istr.get();

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

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

}

// Handling of newlines..

if (ch == '\r') {

ch = '\n';

if (bom == 0 && (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 = (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 = (unsigned char)istr.peek();

istr.unget();

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

ch = (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 unsigned char ch1 = istr.peek();

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

if (ch1 >= 0xfe) {

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

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

return bom | (unsigned char)istr.get();

return 0;

}

// Skip UTF-8 BOM 0xefbbbf

if (ch1 == 0xef) {

istr.get();

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

(void)istr.get();

} else {

istr.unget();

istr.unget();

}

}

return 0;

}

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

}

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 == '\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;

}

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

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

currentToken += ch;

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

delim += ch;

ch = readChar(istr,bom);

}

if (!istr.good() || ch == '\"' || 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.col += currentToken.size() + 2U + 2 * delim.size();

continue;

}

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

if (currentToken.size() < 2U)

// TODO report

return;

}

else {

currentToken += ch;

}

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

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

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

}

}

void simplecpp::TokenList::combineOperators() {

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

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

// float literals..

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

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

deleteToken(tok->previous);

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

}

}

}

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

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

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

// "not" might be !

if (isAlternativeUnaryOp(tok, NOT))

tok->op = '!';

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

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

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::constFoldComparison(Token *tok) {

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

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

}

}

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

{

Token * const tok1 = tok;

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

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

}

}

}

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

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

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

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->previous->number)

continue;

if (!tok->next)

continue;

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

continue;

Token * const condTok = tok->previous;

Token * const trueTok = tok->next;

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

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;

char ch = 0;

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

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

ret += ch;

if (ch == '\\')

ret += (unsigned char)istr.get();

}

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;

}

std::string simplecpp::TokenList::lastLine(int maxsize) const {

std::string ret;

int count = 0;

for (const Token *tok = cback(); sameline(tok,cback()); tok = tok->previous) {

if (tok->comment)

continue;

if (!ret.empty())

ret = ' ' + ret;

ret = (tok->str[0] == '\"' ? std::string("%str%") : tok->str) + ret;

if (++count > maxsize)

return "";

}

return ret;

}

unsigned int simplecpp::TokenList::fileIndex(const std::string &filename) {

for (unsigned int i = 0; i < files.size(); ++i) {

if (files[i] == filename)

return i;

}

files.push_back(filename);

return files.size() - 1U;

}

namespace simplecpp {

class Macro {

public:

explicit Macro(std::vector<std::string> &f) : nameToken(NULL), variadic(false), valueToken(NULL), endToken(NULL), files(f), tokenListDefine(f) {}

Macro(const Token *tok, std::vector<std::string> &f) : nameToken(NULL), files(f), tokenListDefine(f) {

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

throw std::runtime_error("bad macro syntax");

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

throw std::runtime_error("bad macro syntax");

tok = tok->next;

if (!tok || tok->str != DEFINE)

throw std::runtime_error("bad macro syntax");

tok = tok->next;

if (!tok || !tok->name)

throw std::runtime_error("bad macro syntax");

parseDefine(tok);

}

Macro(const std::string &name, const std::string &value, std::vector<std::string> &f) : nameToken(NULL), files(f), tokenListDefine(f) {

const std::string def(name + ' ' + value);

std::istringstream istr(def);

tokenListDefine.readfile(istr);

parseDefine(tokenListDefine.cfront());

}

Macro(const Macro &macro) : nameToken(NULL), files(macro.files), tokenListDefine(macro.files) {

*this = macro;

}

void operator=(const Macro &macro) {

if (this != &macro) {

if (macro.tokenListDefine.empty())

parseDefine(macro.nameToken);

else {

tokenListDefine = macro.tokenListDefine;

parseDefine(tokenListDefine.cfront());

}

}

}

/**

* Expand macro. This will recursively expand inner macros.

* @param output destination tokenlist

* @param rawtok macro token

* @param macros list of macros

* @param files the files

* @return token after macro

* @throw Can throw wrongNumberOfParameters or invalidHashHash

*/

const Token * expand(TokenList * const output,

const Token * rawtok,

const std::map<TokenString,Macro> &macros,

std::vector<std::string> &files) const {

std::set<TokenString> expandedmacros;

TokenList output2(files);

if (functionLike() && rawtok->next && rawtok->next->op == '(') {

// Copy macro call to a new tokenlist with no linebreaks

const Token * const rawtok1 = rawtok;

TokenList rawtokens2(files);

rawtokens2.push_back(new Token(rawtok->str, rawtok1->location));

rawtok = rawtok->next;

rawtokens2.push_back(new Token(rawtok->str, rawtok1->location));

rawtok = rawtok->next;

int par = 1;

while (rawtok && par > 0) {

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

++par;

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

--par;

rawtokens2.push_back(new Token(rawtok->str, rawtok1->location));

rawtok = rawtok->next;

}

if (expand(&output2, rawtok1->location, rawtokens2.cfront(), macros, expandedmacros))

rawtok = rawtok1->next;

} else {

rawtok = expand(&output2, rawtok->location, rawtok, macros, expandedmacros);

}

while (output2.cback() && rawtok) {

unsigned int par = 0;

Token* macro2tok = output2.back();

while (macro2tok) {

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

if (par==0)

break;

--par;

}

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

++par;

macro2tok = macro2tok->previous;

}

if (macro2tok) { // macro2tok->op == '('

macro2tok = macro2tok->previous;

expandedmacros.insert(name());

}

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

macro2tok = output2.back();

if (!macro2tok || !macro2tok->name)

break;

if (output2.cfront() != output2.cback() && macro2tok->str == this->name())

break;

const std::map<TokenString,Macro>::const_iterator macro = macros.find(macro2tok->str);

if (macro == macros.end() || !macro->second.functionLike())

break;

TokenList rawtokens2(files);

const Location loc(macro2tok->location);

while (macro2tok) {

Token *next = macro2tok->next;

rawtokens2.push_back(new Token(macro2tok->str, loc));