#ifndef simplecppH

#define simplecppH

#include <cctype>

#include <cstddef>

#include <istream>

#include <list>

#include <map>

#include <set>

#include <string>

#include <vector>

#ifdef _WIN32

# ifdef SIMPLECPP_EXPORT

# define SIMPLECPP_LIB __declspec(dllexport)

# elif defined(SIMPLECPP_IMPORT)

# define SIMPLECPP_LIB __declspec(dllimport)

# else

# define SIMPLECPP_LIB

# endif

#else

# define SIMPLECPP_LIB

#endif

namespace simplecpp {

typedef std::string TokenString;

/**

class SIMPLECPP_LIB Location {

public:

explicit Location(const std::vector<std::string> &f) : files(f), fileIndex(0), line(1U), col(0U) {}

Location(const Location &loc) : files(loc.files), fileIndex(loc.fileIndex), line(loc.line), col(loc.col) {}

Location &operator=(const Location &other) {

if (this != &other) {

fileIndex = other.fileIndex;

line = other.line;

col = other.col;

}

return *this;

}

/** increment this location by string */

void adjust(const std::string &str);

bool operator<(const Location &rhs) const {

if (fileIndex != rhs.fileIndex)

return fileIndex < rhs.fileIndex;

if (line != rhs.line)

return line < rhs.line;

return col < rhs.col;

}

bool sameline(const Location &other) const {

return fileIndex == other.fileIndex && line == other.line;

}

const std::string& file() const {

return fileIndex < files.size() ? files[fileIndex] : emptyFileName;

}

const std::vector<std::string> &files;

unsigned int fileIndex;

unsigned int line;

unsigned int col;

private:

static const std::string emptyFileName;

};

/**

class SIMPLECPP_LIB Token {

public:

Token(const TokenString &s, const Location &loc) :

location(loc), previous(NULL), next(NULL), string(s) {

flags();

}

Token(const Token &tok) :

macro(tok.macro), location(tok.location), previous(NULL), next(NULL), string(tok.string) {

flags();

}

void flags() {

}

const TokenString& str() const {

return string;

}

void setstr(const std::string &s) {

string = s;

flags();

}

bool isOneOf(const char ops[]) const;

bool startsWithOneOf(const char c[]) const;

bool endsWithOneOf(const char c[]) const;

TokenString macro;

char op;

bool comment;

bool name;

bool number;

Location location;

Token *previous;

Token *next;

const Token *previousSkipComments() const {

const Token *tok = this->previous;

while (tok && tok->comment)

tok = tok->previous;

return tok;

}

const Token *nextSkipComments() const {

const Token *tok = this->next;

while (tok && tok->comment)

tok = tok->next;

return tok;

}

void printAll() const;

void printOut() const;

private:

TokenString string;

// Not implemented - prevent assignment

Token &operator=(const Token &tok);

};

/** Output from preprocessor */

struct SIMPLECPP_LIB Output {

explicit Output(const std::vector<std::string> &files) : type(ERROR), location(files) {}

enum Type {

} type;

Location location;

std::string msg;

};

typedef std::list<Output> OutputList;

/** List of tokens. */

class SIMPLECPP_LIB TokenList {

public:

explicit TokenList(std::vector<std::string> &filenames);

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

TokenList(const TokenList &other);

#if __cplusplus >= 201103L

TokenList(TokenList &&other);

#endif

~TokenList();

TokenList &operator=(const TokenList &other);

#if __cplusplus >= 201103L

TokenList &operator=(TokenList &&other);

#endif

void clear();

bool empty() const {

return !frontToken;

}

void push_back(Token *tok);

void dump() const;

std::string stringify() const;

void readfile(std::istream &istr, const std::string &filename=std::string(), OutputList *outputList = NULL);

void constFold();

void removeComments();

Token *front() {

return frontToken;

}

const Token *cfront() const {

return frontToken;

}

Token *back() {

return backToken;

}

const Token *cback() const {

return backToken;

}

void deleteToken(Token *tok) {

}

void takeTokens(TokenList &other) {

}

/** sizeof(T) */

std::map<std::string, std::size_t> sizeOfType;

private:

void combineOperators();

void constFoldUnaryNotPosNeg(Token *tok);

void constFoldMulDivRem(Token *tok);

void constFoldAddSub(Token *tok);

void constFoldShift(Token *tok);

void constFoldComparison(Token *tok);

void constFoldBitwise(Token *tok);

void constFoldLogicalOp(Token *tok);

void constFoldQuestionOp(Token **tok1);

std::string readUntil(std::istream &istr, const Location &location, char start, char end, OutputList *outputList, unsigned int bom);

void lineDirective(unsigned int fileIndex, unsigned int line, Location *location);

std::string lastLine(int maxsize=100000) const;

unsigned int fileIndex(const std::string &filename);

Token *frontToken;

Token *backToken;

std::vector<std::string> &files;

};

/** Tracking how macros are used */

struct SIMPLECPP_LIB MacroUsage {

explicit MacroUsage(const std::vector<std::string> &f, bool macroValueKnown_) : macroLocation(f), useLocation(f), macroValueKnown(macroValueKnown_) {}

std::string macroName;

Location macroLocation;

Location useLocation;

bool macroValueKnown;

};

/**

struct SIMPLECPP_LIB DUI {

DUI() {}

std::list<std::string> defines;

std::set<std::string> undefined;

std::list<std::string> includePaths;

std::list<std::string> includes;

};

SIMPLECPP_LIB std::map<std::string, TokenList*> load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = NULL);

/**

SIMPLECPP_LIB void preprocess(TokenList &output, const TokenList &rawtokens, std::vector<std::string> &files, std::map<std::string, TokenList*> &filedata, const DUI &dui, OutputList *outputList = NULL, std::list<MacroUsage> *macroUsage = NULL);

/**

SIMPLECPP_LIB void cleanup(std::map<std::string, TokenList*> &filedata);

/** Simplify path */

SIMPLECPP_LIB std::string simplifyPath(std::string path);

/** Convert Cygwin path to Windows path */

SIMPLECPP_LIB std::string convertCygwinToWindowsPath(const std::string &cygwinPath);

}

#endif