#include "matchcompiler.h"

#include <string>

#include <cstring>

#include "errorlogger.h"

#include "token.h"

// pattern: &|*|%name%

static inline bool match1(const Token* tok) {

    if (!tok || !(((tok->tokType() == Token::eBitOp) && tok->str() == MatchCompiler::makeConstString("&")) || ((tok->tokType() == Token::eArithmeticalOp) && tok->str() == MatchCompiler::makeConstString("*")) || tok->isName()))

        return false;

    return true;

}

// pattern: if|for|while (

static inline bool match2(const Token* tok) {

    if (!tok || !(((tok->tokType() == Token::eKeyword) && tok->str() == MatchCompiler::makeConstString("if")) || ((tok->tokType() == Token::eKeyword) && tok->str() == MatchCompiler::makeConstString("for")) || ((tok->tokType() == Token::eKeyword) && tok->str() == MatchCompiler::makeConstString("while"))))

        return false;

    tok = tok->next();

    if (!tok || !((tok->tokType() == Token::eExtendedOp) && tok->str() == MatchCompiler::makeConstString("(")))

        return false;

    return true;

}

// pattern: [;{}]

static inline bool match3(const Token* tok) {

    if (!tok || tok->str().size() != 1U || !strchr(";{}", tok->str()[0]))

        return false;

    return true;

}

// pattern: , }

static inline bool match4(const Token* tok) {

    if (!tok || !((tok->tokType() == Token::eExtendedOp) && tok->str() == MatchCompiler::makeConstString(",")))

        return false;

    tok = tok->next();

    if (!tok || !((tok->tokType() == Token::eBracket) && tok->str() == MatchCompiler::makeConstString("}")))

        return false;

    return true;

}

// pattern: sizeof (

static inline bool match5(const Token* tok) {

    if (!tok || !((tok->tokType() == Token::eKeyword) && tok->str() == MatchCompiler::makeConstString("sizeof")))

        return false;

    tok = tok->next();

    if (!tok || !((tok->tokType() == Token::eExtendedOp) && tok->str() == MatchCompiler::makeConstString("(")))

        return false;

    return true;

}

// pattern: (|)|[|]|{|}

static inline bool match6(const Token* tok) {

    if (!tok || !(((tok->tokType() == Token::eExtendedOp) && tok->str() == MatchCompiler::makeConstString("(")) || ((tok->tokType() == Token::eExtendedOp) && tok->str() == MatchCompiler::makeConstString(")")) || ((tok->tokType() == Token::eExtendedOp || tok->tokType() == Token::eLambda) && tok->str() == MatchCompiler::makeConstString("[")) || ((tok->tokType() == Token::eExtendedOp || tok->tokType() == Token::eLambda) && tok->str() == MatchCompiler::makeConstString("]")) || ((tok->tokType() == Token::eBracket) && tok->str() == MatchCompiler::makeConstString("{")) || ((tok->tokType() == Token::eBracket) && tok->str() == MatchCompiler::makeConstString("}"))))

        return false;

    return true;

}

/*

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

 * Copyright (C) 2007-2024 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 "clangimport.h"

#include "errortypes.h"

#include "mathlib.h"

#include "settings.h"

#include "standards.h"

#include "symboldatabase.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include "utils.h"

#include "vfvalue.h"

#include <algorithm>

#include <cctype>

#include <cstring>

#include <iostream>

#include <iterator>

#include <list>

#include <map>

#include <memory>

#include <set>

#include <sstream>

#include <stack>

#include <string>

#include <utility>

#include <vector>

#include <numeric>

static const std::string AccessSpecDecl = "AccessSpecDecl";

static const std::string ArraySubscriptExpr = "ArraySubscriptExpr";

static const std::string BinaryOperator = "BinaryOperator";

static const std::string BreakStmt = "BreakStmt";

static const std::string CallExpr = "CallExpr";

static const std::string CaseStmt = "CaseStmt";

static const std::string CharacterLiteral = "CharacterLiteral";

static const std::string ClassTemplateDecl = "ClassTemplateDecl";

static const std::string ClassTemplateSpecializationDecl = "ClassTemplateSpecializationDecl";

static const std::string ConditionalOperator = "ConditionalOperator";

static const std::string ConstantExpr = "ConstantExpr";

static const std::string CompoundAssignOperator = "CompoundAssignOperator";

static const std::string CompoundStmt = "CompoundStmt";

static const std::string ContinueStmt = "ContinueStmt";

static const std::string CStyleCastExpr = "CStyleCastExpr";

static const std::string CXXBindTemporaryExpr = "CXXBindTemporaryExpr";

static const std::string CXXBoolLiteralExpr = "CXXBoolLiteralExpr";

static const std::string CXXConstructorDecl = "CXXConstructorDecl";

static const std::string CXXConstructExpr = "CXXConstructExpr";

static const std::string CXXDefaultArgExpr = "CXXDefaultArgExpr";

static const std::string CXXDeleteExpr = "CXXDeleteExpr";

static const std::string CXXDestructorDecl = "CXXDestructorDecl";

static const std::string CXXForRangeStmt = "CXXForRangeStmt";

static const std::string CXXFunctionalCastExpr = "CXXFunctionalCastExpr";

static const std::string CXXMemberCallExpr = "CXXMemberCallExpr";

static const std::string CXXMethodDecl = "CXXMethodDecl";

static const std::string CXXNewExpr = "CXXNewExpr";

static const std::string CXXNullPtrLiteralExpr = "CXXNullPtrLiteralExpr";

static const std::string CXXOperatorCallExpr = "CXXOperatorCallExpr";

static const std::string CXXRecordDecl = "CXXRecordDecl";

static const std::string CXXStaticCastExpr = "CXXStaticCastExpr";

static const std::string CXXStdInitializerListExpr = "CXXStdInitializerListExpr";

static const std::string CXXTemporaryObjectExpr = "CXXTemporaryObjectExpr";

static const std::string CXXThisExpr = "CXXThisExpr";

static const std::string CXXThrowExpr = "CXXThrowExpr";

static const std::string DeclRefExpr = "DeclRefExpr";

static const std::string DeclStmt = "DeclStmt";

static const std::string DefaultStmt = "DefaultStmt";

static const std::string DoStmt = "DoStmt";

static const std::string EnumConstantDecl = "EnumConstantDecl";

static const std::string EnumDecl = "EnumDecl";

static const std::string ExprWithCleanups = "ExprWithCleanups";

static const std::string FieldDecl = "FieldDecl";

static const std::string FloatingLiteral = "FloatingLiteral";

static const std::string ForStmt = "ForStmt";

static const std::string FunctionDecl = "FunctionDecl";

static const std::string FunctionTemplateDecl = "FunctionTemplateDecl";

static const std::string GotoStmt = "GotoStmt";

static const std::string IfStmt = "IfStmt";

static const std::string ImplicitCastExpr = "ImplicitCastExpr";

static const std::string InitListExpr = "InitListExpr";

static const std::string IntegerLiteral = "IntegerLiteral";

static const std::string LabelStmt = "LabelStmt";

static const std::string LinkageSpecDecl = "LinkageSpecDecl";

static const std::string MaterializeTemporaryExpr = "MaterializeTemporaryExpr";

static const std::string MemberExpr = "MemberExpr";

static const std::string NamespaceDecl = "NamespaceDecl";

static const std::string NullStmt = "NullStmt";

static const std::string ParenExpr = "ParenExpr";

static const std::string ParmVarDecl = "ParmVarDecl";

static const std::string RecordDecl = "RecordDecl";

static const std::string ReturnStmt = "ReturnStmt";

static const std::string StringLiteral = "StringLiteral";

static const std::string SwitchStmt = "SwitchStmt";

static const std::string TemplateArgument = "TemplateArgument";

static const std::string TypedefDecl = "TypedefDecl";

static const std::string UnaryOperator = "UnaryOperator";

static const std::string UnaryExprOrTypeTraitExpr = "UnaryExprOrTypeTraitExpr";

static const std::string VarDecl = "VarDecl";

static const std::string WhileStmt = "WhileStmt";

static std::string unquote(const std::string &s)

{

    return (s[0] == '\'') ? s.substr(1, s.size() - 2) : s;

}

static std::vector<std::string> splitString(const std::string &line)

{

    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;

}

namespace clangimport {

    struct Data {

        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.emplace(addr, decl);

            nameToken->enumerator(enumerator);

            notFound(addr);

        }

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

            Decl decl(nameToken, function);

            mDeclMap.emplace(addr, decl);

            nameToken->function(function);

            notFound(addr);

        }

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

            Decl decl(scope);

            mDeclMap.emplace(addr, decl);

        }

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

            Decl decl(def, var);

            mDeclMap.emplace(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;

    };

    class AstNode;

    using AstNodePtr = std::shared_ptr<AstNode>;

    class AstNode {

    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;

        bool isPrologueTypedefDecl() const;

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

                return;

            if (!tokenList.back()) {

                setLocations(tokenList, 0, 1, 1);

            }

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

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

    };

}

std::string clangimport::AstNode::getSpelling() const

{

    if (nodeType == CompoundAssignOperator) {

        std::size_t typeIndex = 1;

        while (typeIndex < mExtTokens.size() && mExtTokens[typeIndex][0] != '\'')

            typeIndex++;

        // name is next quoted token

        std::size_t nameIndex = typeIndex + 1;

        while (nameIndex < mExtTokens.size() && mExtTokens[nameIndex][0] != '\'')

            nameIndex++;

        return (nameIndex < mExtTokens.size()) ? unquote(mExtTokens[nameIndex]) : "";

    }

    if (nodeType == UnaryExprOrTypeTraitExpr) {

        std::size_t typeIndex = 1;

        while (typeIndex < mExtTokens.size() && mExtTokens[typeIndex][0] != '\'')

            typeIndex++;

        const std::size_t nameIndex = typeIndex + 1;

        return (nameIndex < mExtTokens.size()) ? unquote(mExtTokens[nameIndex]) : "";

    }

    int typeIndex = mExtTokens.size() - 1;

    if (nodeType == FunctionDecl || nodeType == CXXConstructorDecl || nodeType == CXXMethodDecl) {

        while (typeIndex >= 0 && mExtTokens[typeIndex][0] != '\'')

            typeIndex--;

        if (typeIndex <= 0)

            return "";

    }

    if (nodeType == DeclRefExpr) {

        while (typeIndex > 0 && std::isalpha(mExtTokens[typeIndex][0]))

            typeIndex--;

        if (typeIndex <= 0)

            return "";

    }

    const std::string &str = mExtTokens[typeIndex - 1];

    if (startsWith(str,"col:"))

        return "";

    if (startsWith(str,"<invalid"))

        return "";

    if (nodeType == RecordDecl && str == MatchCompiler::makeConstString("struct"))

        return "";

    return str;

}

std::string clangimport::AstNode::getType(int index) const

{

    std::string type = getFullType(index);

    if (type.find(" (") != std::string::npos) {

        const std::string::size_type pos = type.find(" (");

        type[pos] = '\'';

        type.erase(pos+1);

    }

    if (type.find(" *(") != std::string::npos) {

        const std::string::size_type pos = type.find(" *(") + 2;

        type[pos] = '\'';

        type.erase(pos+1);

    }

    if (type.find(" &(") != std::string::npos) {

        const std::string::size_type pos = type.find(" &(") + 2;

        type[pos] = '\'';

        type.erase(pos+1);

    }

    return unquote(type);

}

std::string clangimport::AstNode::getFullType(int index) const

{

    std::size_t typeIndex = 1;

    while (typeIndex < mExtTokens.size() && mExtTokens[typeIndex][0] != '\'')

        typeIndex++;

    if (typeIndex >= mExtTokens.size())

        return "";

    std::string type = mExtTokens[typeIndex];

    if (type.find("\':\'") != std::string::npos) {

        if (index == 0)

            type.erase(type.find("\':\'") + 1);

        else

            type.erase(0, type.find("\':\'") + 2);

    }

    return type;

}

bool clangimport::AstNode::isDefinition() const

{

    return contains(mExtTokens, "definition");

}

std::string clangimport::AstNode::getTemplateParameters() const

{

    if (children.empty() || children[0]->nodeType != TemplateArgument)

        return "";

    std::string templateParameters;

    for (const AstNodePtr& child: children) {

        if (child->nodeType == TemplateArgument) {

            if (templateParameters.empty())

                templateParameters = "<";

            else

                templateParameters += ",";

            templateParameters += unquote(child->mExtTokens.back());

        }

    }

    return templateParameters + ">";

}

// cppcheck-suppress unusedFunction // only used in comment

void clangimport::AstNode::dumpAst(int num, int indent) const

{

    (void)num;

    std::cout << std::string(indent, ' ') << nodeType;

    for (const auto& tok: mExtTokens)

        std::cout << " " << tok;

    std::cout << std::endl;

    for (int c = 0; c < children.size(); ++c) {

        if (children[c])

            children[c]->dumpAst(c, indent + 2);

        else

            std::cout << std::string(indent + 2, ' ') << "<<<<NULL>>>>>" << std::endl;

    }

}

bool clangimport::AstNode::isPrologueTypedefDecl() const

{

    // these TypedefDecl are included in *any* AST dump and we should ignore them as they should not be of interest to us

    // see https://github.com/llvm/llvm-project/issues/120228#issuecomment-2549212109 for an explanation

    if (nodeType != TypedefDecl)

        return false;

    // TODO: use different values to indicate "<invalid sloc>"?

    if (mFile != 0 || mLine != 1 || mCol != 1)

        return false;

    // TODO: match without using children

    if (children.empty())

        return false;

    if (children[0].get()->mExtTokens.size() < 2)

        return false;

    const auto& type = children[0].get()->mExtTokens[1];

    if (type == MatchCompiler::makeConstString("'__int128'") ||

        type == MatchCompiler::makeConstString("'unsigned __int128'") ||

        type == MatchCompiler::makeConstString("'struct __NSConstantString_tag'") ||

        type == MatchCompiler::makeConstString("'char *'") ||

        type == MatchCompiler::makeConstString("'struct __va_list_tag[1]'"))

    {

        // NOLINTNEXTLINE(readability-simplify-boolean-expr)

        return true;

    }

    return false;

}

void clangimport::AstNode::setLocations(TokenList &tokenList, int file, int line, int col)

{

    if (mExtTokens.size() >= 2)

    {

        const std::string &ext = mExtTokens[1];

        if (startsWith(ext, "<col:"))

            col = strToInt<int>(ext.substr(5, ext.find_first_of(",>", 5) - 5));

        else if (startsWith(ext, "<line:")) {

            line = strToInt<int>(ext.substr(6, ext.find_first_of(":,>", 6) - 6));

            const auto pos = ext.find(", col:");

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

                col = strToInt<int>(ext.substr(pos+6, ext.find_first_of(":,>", pos+6) - (pos+6)));

        } else if (ext[0] == '<') {

            const std::string::size_type colon = ext.find(':');

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

                const bool windowsPath = colon == 2 && ext.size() > 3 && ext[2] == ':';

                const std::string::size_type sep1 = windowsPath ? ext.find(':', 4) : colon;

                const std::string::size_type sep2 = ext.find(':', sep1 + 1);

                file = tokenList.appendFileIfNew(ext.substr(1, sep1 - 1));

                line = strToInt<int>(ext.substr(sep1 + 1, sep2 - sep1 - 1));

            }

            else {

                // "<invalid sloc>" are encountered in every AST dump by some built-in TypedefDecl

                // an completely empty location block was encountered with a CompoundStmt

                if (ext != MatchCompiler::makeConstString("<<invalid sloc>") && ext != MatchCompiler::makeConstString("<>"))

                    throw InternalError(nullptr, "invalid AST location: " + ext, InternalError::AST);

            }

        }

    }

    mFile = file;

    mLine = line;

    mCol = col;

    for (const auto& child: children) {

        if (child)

            child->setLocations(tokenList, file, line, col);

    }

}

Token *clangimport::AstNode::addtoken(TokenList &tokenList, const std::string &str, bool valueType)

{

    const Scope *scope = getNestedInScope(tokenList);

    tokenList.addtoken(str, mLine, mCol, mFile);

    tokenList.back()->scope(scope);

    if (valueType)

        setValueType(tokenList.back());

    return tokenList.back();

}

const ::Type * clangimport::AstNode::addTypeTokens(TokenList &tokenList, const std::string &str, const Scope *scope)

{

    if (str.find("\':\'") != std::string::npos) {

        return addTypeTokens(tokenList, str.substr(0, str.find("\':\'") + 1), scope);

    }

    if (startsWith(str, "'enum (anonymous"))

        return nullptr;

    std::string type;

    if (str.find(" (") != std::string::npos) {

        if (str.find('<') != std::string::npos)

            type = str.substr(1, str.find('<')) + "...>";

        else

            type = str.substr(1,str.find(" (")-1);

    } else

        type = unquote(str);

    if (type.find("(*)(") != std::string::npos) {

        type.erase(type.find("(*)("));

        type += "*";

    }

    if (type.find('(') != std::string::npos)

        type.erase(type.find('('));

    // TODO: put in a helper?

    std::stack<Token *> lpar;

    for (const std::string &s: splitString(type)) {

        Token *tok = addtoken(tokenList, s, false);

        if (tok->str() == MatchCompiler::makeConstString("("))

            lpar.push(tok);

        else if (tok->str() == MatchCompiler::makeConstString(")")) {

            Token::createMutualLinks(tok, lpar.top());

            lpar.pop();

        }

    }

    // Set Type

    if (!scope) {

        scope = tokenList.back() ? tokenList.back()->scope() : nullptr;

        if (!scope)

            return nullptr;

    }

    for (const Token *typeToken = tokenList.back(); match1(typeToken); typeToken = typeToken->previous()) {

        if (!typeToken->isName())

            continue;

        const ::Type *recordType = scope->check->findVariableType(scope, typeToken);

        if (recordType) {

            const_cast<Token*>(typeToken)->type(recordType);

            return recordType;

        }

    }

    return nullptr;

}

void clangimport::AstNode::addFullScopeNameTokens(TokenList &tokenList, const Scope *recordScope)

{

    if (!recordScope)

        return;

    std::list<const Scope *> scopes;

    while (recordScope && recordScope != tokenList.back()->scope() && !recordScope->isExecutable()) {

        scopes.push_front(recordScope);

        recordScope = recordScope->nestedIn;

    }

    for (const Scope *s: scopes) {

        if (!s->className.empty()) {

            addtoken(tokenList, s->className);

            addtoken(tokenList, "::");

        }

    }

}

const Scope *clangimport::AstNode::getNestedInScope(TokenList &tokenList)

{

    if (!tokenList.back())

        return &mData->mSymbolDatabase->scopeList.front();

    if (tokenList.back()->str() == MatchCompiler::makeConstString("}") && mData->mNotScope.find(tokenList.back()) == mData->mNotScope.end())

        return tokenList.back()->scope()->nestedIn;

    return tokenList.back()->scope();

}

void clangimport::AstNode::setValueType(Token *tok)

{

    for (int i = 0; i < 2; i++) {

        const std::string &type = getType(i);

        if (type.find('<') != std::string::npos)

            // TODO

            continue;

        TokenList decl(nullptr);

        decl.setLang(tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);

        addTypeTokens(decl, type, tok->scope());

        if (!decl.front())

            break;

        const ValueType valueType = ValueType::parseDecl(decl.front(), *mData->mSettings);

        if (valueType.type != ValueType::Type::UNKNOWN_TYPE) {

            tok->setValueType(new ValueType(valueType));

            break;

        }

    }

}

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

{

    std::vector<AstNodePtr> children2{std::move(astNode)};

    return createScope(tokenList, scopeType, children2, def);

}

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

{

    SymbolDatabase *symbolDatabase = mData->mSymbolDatabase;

    auto *nestedIn = const_cast<Scope *>(getNestedInScope(tokenList));

    symbolDatabase->scopeList.emplace_back(nullptr, nullptr, nestedIn);

    Scope *scope = &symbolDatabase->scopeList.back();

    if (scopeType == Scope::ScopeType::eEnum)

        scope->enumeratorList.reserve(children2.size());

    nestedIn->nestedList.push_back(scope);

    scope->type = scopeType;

    scope->classDef = def;

    scope->check = nestedIn->check;

    if (match2(def)) {

        std::map<const Variable *, const Variable *> replaceVar;

        for (const Token *vartok = def->tokAt(2); vartok; vartok = vartok->next()) {

            if (!vartok->variable())

                continue;

            if (vartok->variable()->nameToken() == vartok) {

                const Variable *from = vartok->variable();

                scope->varlist.emplace_back(*from, scope);

                Variable *to = &scope->varlist.back();

                replaceVar[from] = to;

                mData->replaceVarDecl(from, to);

            }

            if (replaceVar.find(vartok->variable()) != replaceVar.end())

                const_cast<Token *>(vartok)->variable(replaceVar[vartok->variable()]);

        }

        std::list<Variable> &varlist = const_cast<Scope *>(def->scope())->varlist;

        for (auto var = varlist.cbegin(); var != varlist.cend();) {

            if (replaceVar.find(&(*var)) != replaceVar.end())

                var = varlist.erase(var);

            else

                ++var;

        }

    }

    scope->bodyStart = addtoken(tokenList, "{");

    tokenList.back()->scope(scope);

    mData->scopeAccessControl[scope] = scope->defaultAccess();

    if (!children2.empty()) {

        for (const AstNodePtr &astNode: children2) {

            if (astNode->nodeType == MatchCompiler::makeConstString("VisibilityAttr"))

                continue;

            if (astNode->nodeType == AccessSpecDecl) {

                if (contains(astNode->mExtTokens, "private"))

                    mData->scopeAccessControl[scope] = AccessControl::Private;

                else if (contains(astNode->mExtTokens, "protected"))

                    mData->scopeAccessControl[scope] = AccessControl::Protected;

                else if (contains(astNode->mExtTokens, "public"))

                    mData->scopeAccessControl[scope] = AccessControl::Public;

                continue;

            }

            astNode->createTokens(tokenList);

            if (scopeType == Scope::ScopeType::eEnum)

                astNode->addtoken(tokenList, ",");

            else if (!match3(tokenList.back()))

                astNode->addtoken(tokenList, ";");

        }

    }

    scope->bodyEnd = addtoken(tokenList, "}");

    Token::createMutualLinks(const_cast<Token*>(scope->bodyStart), const_cast<Token*>(scope->bodyEnd));

    mData->scopeAccessControl.erase(scope);

    return scope;

}

Token *clangimport::AstNode::createTokens(TokenList &tokenList)

{

    if (nodeType == ArraySubscriptExpr) {

        Token *array = getChild(0)->createTokens(tokenList);

        Token *bracket1 = addtoken(tokenList, "[");

        Token *index = children[1]->createTokens(tokenList);

        Token *bracket2 = addtoken(tokenList, "]");

        bracket1->astOperand1(array);

        bracket1->astOperand2(index);

        bracket1->link(bracket2);

        bracket2->link(bracket1);

        return bracket1;

    }

    if (nodeType == BinaryOperator) {

        Token *tok1 = getChild(0)->createTokens(tokenList);

        Token *binop = addtoken(tokenList, unquote(mExtTokens.back()));

        Token *tok2 = children[1]->createTokens(tokenList);

        binop->astOperand1(tok1);

        binop->astOperand2(tok2);

        return binop;

    }

    if (nodeType == BreakStmt)

        return addtoken(tokenList, "break");

    if (nodeType == CharacterLiteral) {

        const int c = MathLib::toBigNumber(mExtTokens.back());

        if (c == 0)

            return addtoken(tokenList, "\'\\0\'");

        if (c == '\r')

            return addtoken(tokenList, "\'\\r\'");

        if (c == '\n')

            return addtoken(tokenList, "\'\\n\'");

        if (c == '\t')

            return addtoken(tokenList, "\'\\t\'");

        if (c == '\\')

            return addtoken(tokenList, "\'\\\\\'");

        if (c < ' ' || c >= 0x80) {

            std::ostringstream hex;

            hex << std::hex << ((c>>4) & 0xf) << (c&0xf);

            return addtoken(tokenList, "\'\\x" + hex.str() + "\'");

        }

        return addtoken(tokenList, std::string("\'") + char(c) + std::string("\'"));

    }

    if (nodeType == CallExpr)