/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2014 Daniel Marjamäki and Cppcheck team.

*

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

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program 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 General Public License for more details.

*

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

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

*/

#include "preprocessor.h"

#include "tokenize.h"

#include "token.h"

#include "path.h"

#include "errorlogger.h"

#include "settings.h"

#include <algorithm>

#include <sstream>

#include <fstream>

#include <cstdlib>

#include <cctype>

#include <vector>

#include <set>

#include <stack>

bool Preprocessor::missingIncludeFlag;

bool Preprocessor::missingSystemIncludeFlag;

char Preprocessor::macroChar = char(1);

Preprocessor::Preprocessor(Settings *settings, ErrorLogger *errorLogger) : _settings(settings), _errorLogger(errorLogger)

{

}

void Preprocessor::writeError(const std::string &fileName, const unsigned int linenr, ErrorLogger *errorLogger, const std::string &errorType, const std::string &errorText)

{

if (!errorLogger)

return;

std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;

ErrorLogger::ErrorMessage::FileLocation loc;

loc.line = linenr;

loc.setfile(fileName);

locationList.push_back(loc);

errorLogger->reportErr(ErrorLogger::ErrorMessage(locationList,

Severity::error,

errorText,

errorType,

false));

}

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

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

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;

}

// Concatenates a list of strings, inserting a separator between parts

static std::string join(const std::set<std::string>& list, char separator)

{

std::string s;

for (std::set<std::string>::const_iterator it = list.begin(); it != list.end(); ++it) {

if (!s.empty())

s += separator;

s += *it;

}

return s;

}

// Removes duplicate string portions separated by the specified separator

static std::string unify(const std::string &s, char separator)

{

std::set<std::string> parts;

std::string::size_type prevPos = 0;

for (std::string::size_type pos = 0; pos < s.length(); ++pos) {

if (s[pos] == separator) {

if (pos > prevPos)

parts.insert(s.substr(prevPos, pos - prevPos));

prevPos = pos + 1;

}

}

if (prevPos < s.length())

parts.insert(s.substr(prevPos));

return join(parts, separator);

}

bool Preprocessor::cplusplus(const Settings *settings, const std::string &filename)

{

const bool undef = settings && settings->userUndefs.find("__cplusplus") != settings->userUndefs.end();

const bool cpplang = settings && settings->enforcedLang == Settings::CPP;

const bool cppfile = (!settings || settings->enforcedLang == Settings::None) && Path::isCPP(filename);

return (!undef && (cpplang || cppfile));

}

/**

* Get cfgmap - a map of macro names and values

*/

static std::map<std::string,std::string> getcfgmap(const std::string &cfg, const Settings *settings, const std::string &filename)

{

std::map<std::string, std::string> cfgmap;

if (!cfg.empty()) {

std::string::size_type pos = 0;

for (;;) {

std::string::size_type pos2 = cfg.find_first_of(";=", pos);

if (pos2 == std::string::npos) {

cfgmap[cfg.substr(pos)] = "";

break;

}

if (cfg[pos2] == ';') {

cfgmap[cfg.substr(pos, pos2-pos)] = "";

} else {

std::string::size_type pos3 = pos2;

pos2 = cfg.find(";", pos2);

if (pos2 == std::string::npos) {

cfgmap[cfg.substr(pos, pos3-pos)] = cfg.substr(pos3 + 1);

break;

} else {

cfgmap[cfg.substr(pos, pos3-pos)] = cfg.substr(pos3 + 1, pos2 - pos3 - 1);

}

}

pos = pos2 + 1;

}

}

if (cfgmap.find("__cplusplus") == cfgmap.end() && Preprocessor::cplusplus(settings,filename))

cfgmap["__cplusplus"] = "1";

return cfgmap;

}

/** Just read the code into a string. Perform simple cleanup of the code */

std::string Preprocessor::read(std::istream &istr, const std::string &filename)

{

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

unsigned int bom = 0;

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

bom = ((unsigned int)istr.get() << 8);

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

bom |= (unsigned int)istr.get();

else

bom = 0; // allowed boms are 0/0xfffe/0xfeff

}

if (_settings && _settings->terminated())

return "";

if (_settings && _settings->checkConfiguration)

return readpreprocessor(istr,bom);

// ------------------------------------------------------------------------------------------

//

// handling <backslash><newline>

// when this is encountered the <backslash><newline> will be "skipped".

// on the next <newline>, extra newlines will be added

std::ostringstream code;

unsigned int newlines = 0;

for (unsigned char ch = readChar(istr,bom); istr.good(); ch = readChar(istr,bom)) {

// Replace assorted special chars with spaces..

if (((ch & 0x80) == 0) && (ch != '\n') && (std::isspace(ch) || std::iscntrl(ch)))

ch = ' ';

// <backslash><newline>..

// for gcc-compatibility the trailing spaces should be ignored

// for vs-compatibility the trailing spaces should be kept

// See tickets #640 and #1869

// The solution for now is to have a compiler-dependent behaviour.

if (ch == '\\') {

unsigned char chNext;

std::string spaces;

#ifdef __GNUC__

// gcc-compatibility: ignore spaces

for (;; spaces += ' ') {

chNext = (unsigned char)istr.peek();

if (chNext != '\n' && chNext != '\r' &&

(std::isspace(chNext) || std::iscntrl(chNext))) {

// Skip whitespace between <backslash> and <newline>

(void)readChar(istr,bom);

continue;

}

break;

}

#else

// keep spaces

chNext = (unsigned char)istr.peek();

#endif

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

++newlines;

(void)readChar(istr,bom); // Skip the "<backslash><newline>"

} else {

code << "\\" << spaces;

}

} else {

code << char(ch);

// if there has been <backslash><newline> sequences, add extra newlines..

if (ch == '\n' && newlines > 0) {

code << std::string(newlines, '\n');

newlines = 0;

}

}

}

std::string result = code.str();

code.str("");

// ------------------------------------------------------------------------------------------

//

// Remove all comments..

result = removeComments(result, filename);

if (_settings && _settings->terminated())

return "";

// ------------------------------------------------------------------------------------------

//

// Clean up all preprocessor statements

result = preprocessCleanupDirectives(result);

if (_settings && _settings->terminated())

return "";

// ------------------------------------------------------------------------------------------

//

// Clean up preprocessor #if statements with Parentheses

result = removeParentheses(result);

if (_settings && _settings->terminated())

return "";

// Remove '#if 0' blocks

if (result.find("#if 0\n") != std::string::npos)

result = removeIf0(result);

if (_settings && _settings->terminated())

return "";

return result;

}

/** read preprocessor statements */

std::string Preprocessor::readpreprocessor(std::istream &istr, const unsigned int bom) const

{

enum { NEWLINE, SPACE, PREPROCESSOR, BACKSLASH, OTHER } state = NEWLINE;

std::ostringstream code;

unsigned int newlines = 1;

unsigned char chPrev = ' ';

for (unsigned char ch = readChar(istr,bom); istr.good(); ch = readChar(istr,bom)) {

// Replace assorted special chars with spaces..

if (((ch & 0x80) == 0) && (ch != '\n') && (std::isspace(ch) || std::iscntrl(ch)))

ch = ' ';

if (ch == ' ' && chPrev == ' ')

continue;

if (state == PREPROCESSOR && chPrev == '/' && (ch == '/' || ch == '*'))

state = OTHER;

chPrev = ch;

if (ch == '\n') {

if (state != BACKSLASH) {

state = NEWLINE;

code << std::string(newlines, '\n');

newlines = 1;

} else {

++newlines;

state = PREPROCESSOR;

}

continue;

}

switch (state) {

case NEWLINE:

if (ch==' ')

state = SPACE;

else if (ch == '#') {

state = PREPROCESSOR;

code << ch;

} else

state = OTHER;

break;

case SPACE:

if (ch == '#') {

state = PREPROCESSOR;

code << ch;

} else if (ch != ' ')

state = OTHER;

break;

case PREPROCESSOR:

code << ch;

if (ch == '\\')

state = BACKSLASH;

break;

case BACKSLASH:

code << ch;

if (ch != ' ')

state = PREPROCESSOR;

break;

case OTHER:

break;

};

}

std::string result = preprocessCleanupDirectives(code.str());

result = removeParentheses(result);

return removeIf0(result);

}

std::string Preprocessor::preprocessCleanupDirectives(const std::string &processedFile)

{

std::ostringstream code;

std::istringstream sstr(processedFile);

std::string line;

while (std::getline(sstr, line)) {

// Trim lines..

if (!line.empty() && line[0] == ' ')

line.erase(0, line.find_first_not_of(" "));

if (!line.empty() && line[line.size()-1] == ' ')

line.erase(line.find_last_not_of(" ") + 1);

// Preprocessor

if (!line.empty() && line[0] == '#') {

enum {

ESC_NONE,

ESC_SINGLE,

ESC_DOUBLE

} escapeStatus = ESC_NONE;

char prev = ' '; // hack to make it skip spaces between # and the directive

code << "#";

std::string::const_iterator i = line.begin();

++i;

// need space.. #if( => #if (

bool needSpace = true;

while (i != line.end()) {

// disable esc-mode

if (escapeStatus != ESC_NONE) {

if (prev != '\\' && escapeStatus == ESC_SINGLE && *i == '\'') {

escapeStatus = ESC_NONE;

}

if (prev != '\\' && escapeStatus == ESC_DOUBLE && *i == '"') {

escapeStatus = ESC_NONE;

}

} else {

// enable esc-mode

if (escapeStatus == ESC_NONE && *i == '"')

escapeStatus = ESC_DOUBLE;

if (escapeStatus == ESC_NONE && *i == '\'')

escapeStatus = ESC_SINGLE;

}

// skip double whitespace between arguments

if (escapeStatus == ESC_NONE && prev == ' ' && *i == ' ') {

++i;

continue;

}

// Convert #if( to "#if ("

if (escapeStatus == ESC_NONE) {

if (needSpace) {

if (*i == '(' || *i == '!')

code << " ";

else if (!std::isalpha((unsigned char)*i))

needSpace = false;

}

if (*i == '#')

needSpace = true;

}

code << *i;

if (escapeStatus != ESC_NONE && prev == '\\' && *i == '\\') {

prev = ' ';

} else {

prev = *i;

}

++i;

}

if (escapeStatus != ESC_NONE) {

// unmatched quotes.. compiler should probably complain about this..

}

} else {

// Do not mess with regular code..

code << line;

}

code << (sstr.eof()?"":"\n");

}

return code.str();

}

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

{

return bool(str.size() >= 3 &&

static_cast<unsigned char>(str[0]) == 0xef &&

static_cast<unsigned char>(str[1]) == 0xbb &&

static_cast<unsigned char>(str[2]) == 0xbf);

}

// This wrapper exists because Sun's CC does not allow a static_cast

// from extern "C" int(*)(int) to int(*)(int).

static int tolowerWrapper(int c)

{

return std::tolower(c);

}

static bool isFallThroughComment(std::string comment)

{

// convert comment to lower case without whitespace

for (std::string::iterator i = comment.begin(); i != comment.end();) {

if (std::isspace(static_cast<unsigned char>(*i)))

i = comment.erase(i);

else

++i;

}

std::transform(comment.begin(), comment.end(), comment.begin(), tolowerWrapper);

return comment.find("fallthr") != std::string::npos ||

comment.find("fallsthr") != std::string::npos ||

comment.find("fall-thr") != std::string::npos ||

comment.find("dropthr") != std::string::npos ||

comment.find("passthr") != std::string::npos ||

comment.find("nobreak") != std::string::npos ||

comment == "fall";

}

std::string Preprocessor::removeComments(const std::string &str, const std::string &filename)

{

// For the error report

unsigned int lineno = 1;

// handling <backslash><newline>

// when this is encountered the <backslash><newline> will be "skipped".

// on the next <newline>, extra newlines will be added

unsigned int newlines = 0;

std::ostringstream code;

unsigned char previous = 0;

bool inPreprocessorLine = false;

std::vector<std::string> suppressionIDs;

bool fallThroughComment = false;

for (std::string::size_type i = hasbom(str) ? 3U : 0U; i < str.length(); ++i) {

unsigned char ch = static_cast<unsigned char>(str[i]);

if (ch & 0x80) {

std::ostringstream errmsg;

errmsg << "The code contains characters that are unhandled. "

<< "Neither unicode nor extended ASCII are supported. "

<< "(line=" << lineno << ", character code=" << std::hex << (int(ch) & 0xff) << ")";

writeError(filename, lineno, _errorLogger, "syntaxError", errmsg.str());

}

if (_settings && _settings->terminated())

return "";

if ((str.compare(i, 7, "#error ") == 0 && (!_settings || _settings->userDefines.empty())) ||

str.compare(i, 9, "#warning ") == 0) {

if (str.compare(i, 6, "#error") == 0)

code << "#error";

i = str.find("\n", i);

if (i == std::string::npos)

break;

--i;

continue;

}

// First skip over any whitespace that may be present

if (std::isspace(ch)) {

if (ch == ' ' && previous == ' ') {

// Skip double white space

} else {

code << char(ch);

previous = ch;

}

// if there has been <backslash><newline> sequences, add extra newlines..

if (ch == '\n') {

if (previous != '\\')

inPreprocessorLine = false;

++lineno;

if (newlines > 0) {

code << std::string(newlines, '\n');

newlines = 0;

previous = '\n';

}

}

continue;

}

// Remove comments..

if (str.compare(i, 2, "//") == 0) {

std::size_t commentStart = i + 2;

i = str.find('\n', i);

if (i == std::string::npos)

break;

std::string comment(str, commentStart, i - commentStart);

if (_settings && _settings->_inlineSuppressions) {

std::istringstream iss(comment);

std::string word;

iss >> word;

if (word == "cppcheck-suppress") {

iss >> word;

if (iss)

suppressionIDs.push_back(word);

}

}

if (isFallThroughComment(comment)) {

fallThroughComment = true;

}

code << "\n";

previous = '\n';

++lineno;

} else if (str.compare(i, 2, "/*") == 0) {

std::size_t commentStart = i + 2;

unsigned char chPrev = 0;

++i;

while (i < str.length() && (chPrev != '*' || ch != '/')) {

chPrev = ch;

++i;

ch = static_cast<unsigned char>(str[i]);

if (ch == '\n') {

++newlines;

++lineno;

}

}

std::string comment(str, commentStart, i - commentStart - 1);

if (isFallThroughComment(comment)) {

fallThroughComment = true;

}

if (_settings && _settings->_inlineSuppressions) {

std::istringstream iss(comment);

std::string word;

iss >> word;

if (word == "cppcheck-suppress") {

iss >> word;

if (iss)

suppressionIDs.push_back(word);

}

}

} else if ((i == 0 || std::isspace((unsigned char)str[i-1])) && str.compare(i, 5, "__asm") == 0) {

while (i < str.size() && (std::isalpha((unsigned char)str[i]) || str[i] == '_'))

code << str[i++];

while (i < str.size() && std::isspace((unsigned char)str[i]))

code << str[i++];

if (str[i] == '{') {

// Ticket 4873: Extract comments from the __asm / __asm__'s content

std::string asmBody;

while (i < str.size() && str[i] != '}') {

if (str[i] == ';') {

std::string::size_type backslashN = str.find("\n", i);

if (backslashN != std::string::npos) // Ticket #4922: Don't go in infinite loop or crash if there is no '\n'

i = backslashN;

}

asmBody += str[i++];

}

code << removeComments(asmBody, filename);

code << '}';

} else

--i;

} else if (ch == '#' && previous == '\n') {

code << ch;

previous = ch;

inPreprocessorLine = true;

// Add any pending inline suppressions that have accumulated.

if (!suppressionIDs.empty()) {

if (_settings != nullptr) {

// Add the suppressions.

for (std::size_t j = 0; j < suppressionIDs.size(); ++j) {

const std::string errmsg(_settings->nomsg.addSuppression(suppressionIDs[j], filename, lineno));

if (!errmsg.empty()) {

writeError(filename, lineno, _errorLogger, "cppcheckError", errmsg);

}

}

}

suppressionIDs.clear();

}

} else {

if (!inPreprocessorLine) {

// Not whitespace, not a comment, and not preprocessor.

// Must be code here!

// First check for a "fall through" comment match, but only

// add a suppression if the next token is 'case' or 'default'

if (_settings && _settings->isEnabled("style") && _settings->experimental && fallThroughComment) {

std::string::size_type j = str.find_first_not_of("abcdefghijklmnopqrstuvwxyz", i);

std::string tok = str.substr(i, j - i);

if (tok == "case" || tok == "default")

suppressionIDs.push_back("switchCaseFallThrough");

fallThroughComment = false;

}

// Add any pending inline suppressions that have accumulated.

if (!suppressionIDs.empty()) {

if (_settings != nullptr) {

// Relative filename

std::string relativeFilename(filename);

if (_settings->_relativePaths) {

for (std::size_t j = 0U; j < _settings->_basePaths.size(); ++j) {

const std::string bp = _settings->_basePaths[j] + "/";

if (relativeFilename.compare(0,bp.size(),bp)==0) {

relativeFilename = relativeFilename.substr(bp.size());

}

}

}

// Add the suppressions.

for (std::size_t j = 0; j < suppressionIDs.size(); ++j) {

const std::string errmsg(_settings->nomsg.addSuppression(suppressionIDs[j], relativeFilename, lineno));

if (!errmsg.empty()) {

writeError(filename, lineno, _errorLogger, "cppcheckError", errmsg);

}

}

}

suppressionIDs.clear();

}

}

// String or char constants..

if (ch == '\"' || ch == '\'') {

code << char(ch);

char chNext;

do {

++i;

chNext = str[i];

if (chNext == '\\') {

++i;

char chSeq = str[i];

if (chSeq == '\n')

++newlines;

else {

code << chNext;

code << chSeq;

previous = static_cast<unsigned char>(chSeq);

}

} else {

code << chNext;

previous = static_cast<unsigned char>(chNext);

}

} while (i < str.length() && chNext != ch && chNext != '\n');

}

// Rawstring..

else if (str.compare(i,2,"R\"")==0) {

std::string delim;

for (std::string::size_type i2 = i+2; i2 < str.length(); ++i2) {

if (i2 > 16 ||

std::isspace(str[i2]) ||

std::iscntrl(str[i2]) ||

str[i2] == ')' ||

str[i2] == '\\') {

delim = " ";

break;

} else if (str[i2] == '(')

break;

delim += str[i2];

}

const std::string::size_type endpos = str.find(")" + delim + "\"", i);

if (delim != " " && endpos != std::string::npos) {

unsigned int rawstringnewlines = 0;

code << '\"';

for (std::string::size_type p = i + 3 + delim.size(); p < endpos; ++p) {

if (str[p] == '\n') {

rawstringnewlines++;

code << "\\n";

} else if (std::iscntrl((unsigned char)str[p]) ||

std::isspace((unsigned char)str[p])) {

code << " ";

} else if (str[p] == '\"' || str[p] == '\'') {

code << "\\" << (char)str[p];

} else {

code << (char)str[p];

}

}

code << "\"";

if (rawstringnewlines > 0)

code << std::string(rawstringnewlines, '\n');

i = endpos + delim.size() + 1;

} else {

code << "R";

previous = 'R';

}

} else {

code << char(ch);

previous = ch;

}

}

}

return code.str();

}

std::string Preprocessor::removeIf0(const std::string &code)

{

std::ostringstream ret;

std::istringstream istr(code);

std::string line;

while (std::getline(istr,line)) {

ret << line << "\n";

if (line == "#if 0") {

// goto the end of the '#if 0' block

unsigned int level = 1;

bool in = false;

while (level > 0 && std::getline(istr,line)) {

if (line.compare(0,3,"#if") == 0)

++level;

else if (line == "#endif")

--level;

else if ((line == "#else") || (line.compare(0, 5, "#elif") == 0)) {

if (level == 1)

in = true;

} else {

if (in)

ret << line << "\n";

else

// replace code within '#if 0' block with empty lines

ret << "\n";

continue;

}

ret << line << "\n";

}

}

}

return ret.str();

}

std::string Preprocessor::removeParentheses(const std::string &str)

{

if (str.find("\n#if") == std::string::npos && str.compare(0, 3, "#if") != 0)

return str;

std::istringstream istr(str);

std::ostringstream ret;

std::string line;

while (std::getline(istr, line)) {

if (line.compare(0, 3, "#if") == 0 || line.compare(0, 5, "#elif") == 0) {

std::string::size_type pos;

pos = 0;

while ((pos = line.find(" (", pos)) != std::string::npos)

line.erase(pos, 1);

pos = 0;

while ((pos = line.find("( ", pos)) != std::string::npos)

line.erase(pos + 1, 1);

pos = 0;

while ((pos = line.find(" )", pos)) != std::string::npos)

line.erase(pos, 1);

pos = 0;

while ((pos = line.find(") ", pos)) != std::string::npos)

line.erase(pos + 1, 1);

// Remove inner parentheses "((..))"..

pos = 0;

while ((pos = line.find("((", pos)) != std::string::npos) {

++pos;

std::string::size_type pos2 = line.find_first_of("()", pos + 1);

if (pos2 != std::string::npos && line[pos2] == ')') {

line.erase(pos2, 1);

line.erase(pos, 1);

}

}

// "#if(A) => #if A", but avoid "#if (defined A) || defined (B)"

if ((line.compare(0, 4, "#if(") == 0 || line.compare(0, 6, "#elif(") == 0) &&

line[line.length() - 1] == ')') {

int ind = 0;

for (std::string::size_type i = 0; i < line.length(); ++i) {

if (line[i] == '(')

++ind;

else if (line[i] == ')') {

--ind;

if (ind == 0) {

if (i == line.length() - 1) {

line[line.find('(')] = ' ';

line.erase(line.length() - 1);

}

break;

}

}

}

}

if (line.compare(0, 4, "#if(") == 0)

line.insert(3, " ");

else if (line.compare(0, 6, "#elif(") == 0)

line.insert(5, " ");

}

ret << line << "\n";

}

return ret.str();

}

void Preprocessor::removeAsm(std::string &str)

{

std::string::size_type pos = 0;

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

str.replace(pos, 4, "asm(");

std::string::size_type pos2 = str.find("#endasm", pos);

if (pos2 != std::string::npos) {

str.replace(pos2, 7, ");");

pos = pos2;

}

}

}

void Preprocessor::preprocess(std::istream &istr, std::map<std::string, std::string> &result, const std::string &filename, const std::list<std::string> &includePaths)

{

std::list<std::string> configs;

std::string data;

preprocess(istr, data, configs, filename, includePaths);

for (std::list<std::string>::const_iterator it = configs.begin(); it != configs.end(); ++it) {

if (_settings && (_settings->userUndefs.find(*it) == _settings->userUndefs.end())) {

result[ *it ] = getcode(data, *it, filename);

}

}

}

std::string Preprocessor::removeSpaceNearNL(const std::string &str)

{

std::string tmp;

char prev = 0;

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

if (str[i] == ' ' &&

((i > 0 && prev == '\n') ||

(i + 1 < str.size() && str[i+1] == '\n')

)

) {

// Ignore space that has new line in either side of it

} else {

tmp.append(1, str[i]);

prev = str[i];

}

}

return tmp;

}

std::string Preprocessor::replaceIfDefined(const std::string &str) const

{

std::string ret(str);

std::string::size_type pos;

pos = 0;

while ((pos = ret.find("#if defined(", pos)) != std::string::npos) {

std::string::size_type pos2 = ret.find(")", pos + 9);

if (pos2 > ret.length() - 1)

break;

if (ret[pos2+1] == '\n') {

ret.erase(pos2, 1);

ret.erase(pos + 3, 9);

ret.insert(pos + 3, "def ");

}

++pos;

if (_settings && _settings->terminated())

return "";

}

pos = 0;

while ((pos = ret.find("#if !defined(", pos)) != std::string::npos) {

std::string::size_type pos2 = ret.find(")", pos + 9);

if (pos2 > ret.length() - 1)

break;

if (ret[pos2+1] == '\n') {

ret.erase(pos2, 1);

ret.erase(pos + 3, 10);

ret.insert(pos + 3, "ndef ");

}

++pos;

if (_settings && _settings->terminated())

return "";

}

pos = 0;

while ((pos = ret.find("#elif defined(", pos)) != std::string::npos) {

std::string::size_type pos2 = ret.find(")", pos + 9);

if (pos2 > ret.length() - 1)

break;

if (ret[pos2+1] == '\n') {

ret.erase(pos2, 1);

ret.erase(pos + 6, 8);

}

++pos;

if (_settings && _settings->terminated())

return "";

}

return ret;

}

void Preprocessor::preprocessWhitespaces(std::string &processedFile)

{

// Replace all tabs with spaces..

std::replace(processedFile.begin(), processedFile.end(), '\t', ' ');

// Remove all indentation..

if (!processedFile.empty() && processedFile[0] == ' ')

processedFile.erase(0, processedFile.find_first_not_of(" "));

// Remove space characters that are after or before new line character

processedFile = removeSpaceNearNL(processedFile);

}

void Preprocessor::preprocess(std::istream &srcCodeStream, std::string &processedFile, std::list<std::string> &resultConfigurations, const std::string &filename, const std::list<std::string> &includePaths)

{

std::string forcedIncludes;

if (file0.empty())

file0 = filename;

processedFile = read(srcCodeStream, filename);

if (_settings) {

for (std::list<std::string>::iterator it = _settings->userIncludes.begin();

it != _settings->userIncludes.end();

++it) {

std::string cur = *it;

// try to open file

std::ifstream fin;

fin.open(cur.c_str());

if (!fin.is_open()) {

missingInclude(cur,

1,

cur,

UserHeader

);

continue;

}

const std::string fileData = read(fin, filename);

fin.close();

forcedIncludes =

forcedIncludes +

"#file \"" + cur + "\"\n" +

"#line 1\n" +

fileData + "\n" +

"#endfile\n"

;

}

for (std::vector<std::string>::iterator it = _settings->library.defines.begin();

it != _settings->library.defines.end();