{

std::vector<std::string> ret;

std::string::size_type pos1 = line.find_first_not_of(' ');

while (pos1 < line.size()) {

std::string::size_type pos2;

if (std::strchr("*()", line[pos1])) {

ret.push_back(line.substr(pos1,1));

pos1 = line.find_first_not_of(' ', pos1 + 1);

continue;

}

if (line[pos1] == '<')

pos2 = line.find('>', pos1);

else if (line[pos1] == '\"')

pos2 = line.find('\"', pos1+1);

else if (line[pos1] == '\'') {

pos2 = line.find('\'', pos1+1);

if (pos2 < (int)line.size() - 3 && line.compare(pos2, 3, "\':\'", 0, 3) == 0)

pos2 = line.find('\'', pos2 + 3);

} else {

pos2 = pos1;

while (pos2 < line.size() && (line[pos2] == '_' || line[pos2] == ':' || std::isalnum((unsigned char)line[pos2])))

++pos2;

if (pos2 > pos1 && pos2 < line.size() && line[pos2] == '<' && std::isalpha(line[pos1])) {

int tlevel = 1;

while (++pos2 < line.size() && tlevel > 0) {

if (line[pos2] == '<')

++tlevel;

else if (line[pos2] == '>')

--tlevel;

}

if (tlevel == 0 && pos2 < line.size() && line[pos2] == ' ') {

ret.push_back(line.substr(pos1, pos2-pos1));

pos1 = pos2 + 1;

continue;

}

}

pos2 = line.find(' ', pos1) - 1;

if ((std::isalpha(line[pos1]) || line[pos1] == '_') &&

line.find("::", pos1) < pos2 &&

line.find("::", pos1) < line.find('<', pos1)) {

pos2 = line.find("::", pos1);

ret.push_back(line.substr(pos1, pos2-pos1));

ret.emplace_back("::");

pos1 = pos2 + 2;

continue;

}

if ((std::isalpha(line[pos1]) || line[pos1] == '_') &&

line.find('<', pos1) < pos2 &&

line.find("<<",pos1) != line.find('<',pos1) &&

line.find('>', pos1) != std::string::npos &&

line.find('>', pos1) > pos2) {

int level = 0;

for (pos2 = pos1; pos2 < line.size(); ++pos2) {

if (line[pos2] == '<')

++level;

else if (line[pos2] == '>') {

if (level <= 1)

break;

--level;

}

}

if (level > 1 && pos2 + 1 >= line.size())

return std::vector<std::string> {};

pos2 = line.find(' ', pos2);

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

--pos2;

}

}

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

ret.push_back(line.substr(pos1));

break;

}

ret.push_back(line.substr(pos1, pos2+1-pos1));

pos1 = line.find_first_not_of(' ', pos2 + 1);

}

return ret;

struct Decl {

explicit Decl(Scope *scope) : scope(scope) {}

Decl(Token *def, Variable *var) : def(def), var(var) {}

Decl(Token *def, Function *function) : def(def), function(function) {}

Decl(Token *def, Enumerator *enumerator) : def(def), enumerator(enumerator) {}

void ref(Token *tok) const {

if (enumerator)

tok->enumerator(enumerator);

if (function)

tok->function(function);

if (var) {

tok->variable(var);

tok->varId(var->declarationId());

}

}

Token* def{};

Enumerator* enumerator{};

Function* function{};

Scope* scope{};

Variable* var{};

};

const Settings *mSettings = nullptr;

SymbolDatabase *mSymbolDatabase = nullptr;

int enumValue = 0;

void enumDecl(const std::string &addr, Token *nameToken, Enumerator *enumerator) {

Decl decl(nameToken, enumerator);

mDeclMap.insert(std::pair<std::string, Decl>(addr, decl));

nameToken->enumerator(enumerator);

notFound(addr);

}

void funcDecl(const std::string &addr, Token *nameToken, Function *function) {

Decl decl(nameToken, function);

mDeclMap.insert(std::pair<std::string, Decl>(addr, decl));

nameToken->function(function);

notFound(addr);

}

void scopeDecl(const std::string &addr, Scope *scope) {

Decl decl(scope);

mDeclMap.insert(std::pair<std::string, Decl>(addr, decl));

}

void varDecl(const std::string &addr, Token *def, Variable *var) {

Decl decl(def, var);

mDeclMap.insert(std::pair<std::string, Decl>(addr, decl));

def->varId(++mVarId);

def->variable(var);

if (def->valueType())

var->setValueType(*def->valueType());

notFound(addr);

}

void replaceVarDecl(const Variable *from, Variable *to) {

for (auto &it: mDeclMap) {

Decl &decl = it.second;

if (decl.var == from)

decl.var = to;

}

}

void ref(const std::string &addr, Token *tok) {

auto it = mDeclMap.find(addr);

if (it != mDeclMap.end())

it->second.ref(tok);

else

mNotFound[addr].push_back(tok);

}

std::vector<const Variable *> getVariableList() const {

std::vector<const Variable *> ret;

ret.resize(mVarId + 1, nullptr);

for (const auto& it: mDeclMap) {

if (it.second.var)

ret[it.second.var->declarationId()] = it.second.var;

}

return ret;

}

bool hasDecl(const std::string &addr) const {

return mDeclMap.find(addr) != mDeclMap.end();

}

const Scope *getScope(const std::string &addr) {

auto it = mDeclMap.find(addr);

return (it == mDeclMap.end() ? nullptr : it->second.scope);

}

// "}" tokens that are not end-of-scope

std::set<Token *> mNotScope;

std::map<const Scope *, AccessControl> scopeAccessControl;

private:

void notFound(const std::string &addr) {

auto it = mNotFound.find(addr);

if (it != mNotFound.end()) {

for (Token *reftok: it->second)

ref(addr, reftok);

mNotFound.erase(it);

}

}

std::map<std::string, Decl> mDeclMap;

std::map<std::string, std::vector<Token *>> mNotFound;

int mVarId = 0;

public:

AstNode(std::string nodeType, const std::string &ext, Data *data)

: nodeType(std::move(nodeType)), mExtTokens(splitString(ext)), mData(data)

{}

std::string nodeType;

std::vector<AstNodePtr> children;

void setLocations(TokenList &tokenList, int file, int line, int col);

void dumpAst(int num = 0, int indent = 0) const;

void createTokens1(TokenList &tokenList) {

//dumpAst(); // TODO: reactivate or remove

if (!tokenList.back()) {

setLocations(tokenList, 0, 1, 1);

// FIXME: treat as C++ if no filename (i.e. no lang) is specified for now

if (tokenList.getSourceFilePath().empty())

tokenList.setLang(Standards::Language::CPP);

}

else

setLocations(tokenList, tokenList.back()->fileIndex(), tokenList.back()->linenr(), 1);

createTokens(tokenList);

if (nodeType == VarDecl || nodeType == RecordDecl || nodeType == TypedefDecl)

addtoken(tokenList, ";");

mData->mNotScope.clear();

}

AstNodePtr getChild(int c) {

if (c >= children.size()) {

std::ostringstream err;

err << "ClangImport: AstNodePtr::getChild(" << c << ") out of bounds. children.size=" << children.size() << " " << nodeType;

for (const std::string &s: mExtTokens)

err << " " << s;

throw InternalError(nullptr, err.str());

}

return children[c];

}

private:

Token *createTokens(TokenList &tokenList);

Token *addtoken(TokenList &tokenList, const std::string &str, bool valueType=true);

const ::Type *addTypeTokens(TokenList &tokenList, const std::string &str, const Scope *scope = nullptr);

void addFullScopeNameTokens(TokenList &tokenList, const Scope *recordScope);

Scope *createScope(TokenList &tokenList, Scope::ScopeType scopeType, AstNodePtr astNode, const Token *def);

Scope *createScope(TokenList &tokenList, Scope::ScopeType scopeType, const std::vector<AstNodePtr> &children2, const Token *def);

Token *createTokensCall(TokenList &tokenList);

void createTokensFunctionDecl(TokenList &tokenList);

void createTokensForCXXRecord(TokenList &tokenList);

Token *createTokensVarDecl(TokenList &tokenList);

std::string getSpelling() const;

std::string getType(int index = 0) const;

std::string getFullType(int index = 0) const;

bool isDefinition() const;

std::string getTemplateParameters() const;

const Scope *getNestedInScope(TokenList &tokenList);

void setValueType(Token *tok);

int mFile = 0;

int mLine = 1;

int mCol = 1;

std::vector<std::string> mExtTokens;

Data *mData;