std::ostringstream ostr;

ostr << t;

return ostr.str();

{

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

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

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

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

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

{

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;

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;

istr.unget();

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

istr.unget();

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;

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

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

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

const Token * const hashtok = tok;

tok = tok->next;

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

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

tok = tok->next;

if (!tok || !tok->name || !sameline(hashtok,tok))

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

if (!parseDefine(tok))

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

}

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

if (!parseDefine(tokenListDefine.cfront()))

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

}

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

}

}

}

/**

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