#include "parserutils.h" #include #include #include #include #include #include "../utils.h" QStringList CppDirectives; QStringList JavadocTags; QMap CppKeywords; QSet CppTypeKeywords; QSet CKeywords; QSet STLPointers; QSet STLContainers; QSet STLElementMethods; Q_GLOBAL_STATIC(QSet,CppHeaderExts) Q_GLOBAL_STATIC(QSet,CppSourceExts) void initParser() { CppHeaderExts->insert("h"); CppHeaderExts->insert("hpp"); CppHeaderExts->insert("rh"); CppHeaderExts->insert("hh"); CppHeaderExts->insert("hxx"); CppHeaderExts->insert("inl"); CppHeaderExts->insert(""); CppSourceExts->insert("c"); CppSourceExts->insert("cpp"); CppSourceExts->insert("cc"); CppSourceExts->insert("cxx"); CppSourceExts->insert("c++"); CppSourceExts->insert("cp"); // skip itself CppKeywords.insert("and",SkipType::skItself); CppKeywords.insert("and_eq",SkipType::skItself); CppKeywords.insert("bitand",SkipType::skItself); CppKeywords.insert("bitor",SkipType::skItself); CppKeywords.insert("break",SkipType::skItself); CppKeywords.insert("compl",SkipType::skItself); CppKeywords.insert("constexpr",SkipType::skItself); CppKeywords.insert("const_cast",SkipType::skItself); CppKeywords.insert("continue",SkipType::skItself); CppKeywords.insert("dynamic_cast",SkipType::skItself); CppKeywords.insert("else",SkipType::skItself); CppKeywords.insert("explicit",SkipType::skItself); CppKeywords.insert("export",SkipType::skItself); CppKeywords.insert("false",SkipType::skItself); //CppKeywords.insert("for",SkipType::skItself); CppKeywords.insert("mutable",SkipType::skItself); CppKeywords.insert("noexcept",SkipType::skItself); CppKeywords.insert("not",SkipType::skItself); CppKeywords.insert("not_eq",SkipType::skItself); CppKeywords.insert("nullptr",SkipType::skItself); CppKeywords.insert("or",SkipType::skItself); CppKeywords.insert("or_eq",SkipType::skItself); CppKeywords.insert("register",SkipType::skItself); CppKeywords.insert("reinterpret_cast",SkipType::skItself); CppKeywords.insert("static_assert",SkipType::skItself); CppKeywords.insert("static_cast",SkipType::skItself); CppKeywords.insert("template",SkipType::skItself); CppKeywords.insert("this",SkipType::skItself); CppKeywords.insert("thread_local",SkipType::skItself); CppKeywords.insert("true",SkipType::skItself); CppKeywords.insert("typename",SkipType::skItself); CppKeywords.insert("virtual",SkipType::skItself); CppKeywords.insert("volatile",SkipType::skItself); CppKeywords.insert("xor",SkipType::skItself); CppKeywords.insert("xor_eq",SkipType::skItself); //CppKeywords.insert("catch",SkipType::skItself); CppKeywords.insert("do",SkipType::skItself); CppKeywords.insert("try",SkipType::skItself); // Skip to ; CppKeywords.insert("delete",SkipType::skToSemicolon); CppKeywords.insert("delete[]",SkipType::skToSemicolon); CppKeywords.insert("goto",SkipType::skToSemicolon); CppKeywords.insert("new",SkipType::skToSemicolon); CppKeywords.insert("return",SkipType::skToSemicolon); CppKeywords.insert("throw",SkipType::skToSemicolon); // CppKeywords.insert("using",SkipType::skToSemicolon); //won't use it // Skip to : CppKeywords.insert("case",SkipType::skToColon); CppKeywords.insert("default",SkipType::skToColon); // Skip to ) CppKeywords.insert("__attribute__",SkipType::skToRightParenthesis); CppKeywords.insert("alignas",SkipType::skToRightParenthesis); // not right CppKeywords.insert("alignof",SkipType::skToRightParenthesis); // not right CppKeywords.insert("decltype",SkipType::skToRightParenthesis); // not right CppKeywords.insert("if",SkipType::skToRightParenthesis); CppKeywords.insert("sizeof",SkipType::skToRightParenthesis); CppKeywords.insert("switch",SkipType::skToRightParenthesis); CppKeywords.insert("typeid",SkipType::skToRightParenthesis); CppKeywords.insert("while",SkipType::skToRightParenthesis); // Skip to } CppKeywords.insert("asm",SkipType::skToRightBrace); //CppKeywords.insert("namespace",SkipType::skToLeftBrace); // won't process it // Skip to { // wont handle //Not supported yet CppKeywords.insert("atomic_cancel",SkipType::skNone); CppKeywords.insert("atomic_commit",SkipType::skNone); CppKeywords.insert("atomic_noexcept",SkipType::skNone); CppKeywords.insert("concept",SkipType::skNone); CppKeywords.insert("consteval",SkipType::skNone); CppKeywords.insert("constinit",SkipType::skNone); CppKeywords.insert("co_wait",SkipType::skNone); CppKeywords.insert("co_return",SkipType::skNone); CppKeywords.insert("co_yield",SkipType::skNone); CppKeywords.insert("reflexpr",SkipType::skNone); CppKeywords.insert("requires",SkipType::skNone); // its a type CppKeywords.insert("auto",SkipType::skNone); CppKeywords.insert("bool",SkipType::skNone); CppKeywords.insert("char",SkipType::skNone); CppKeywords.insert("char8_t",SkipType::skNone); CppKeywords.insert("char16_t",SkipType::skNone); CppKeywords.insert("char32_t",SkipType::skNone); CppKeywords.insert("double",SkipType::skNone); CppKeywords.insert("float",SkipType::skNone); CppKeywords.insert("int",SkipType::skNone); CppKeywords.insert("long",SkipType::skNone); CppKeywords.insert("short",SkipType::skNone); CppKeywords.insert("signed",SkipType::skNone); CppKeywords.insert("unsigned",SkipType::skNone); CppKeywords.insert("void",SkipType::skNone); CppKeywords.insert("wchar_t",SkipType::skNone); // type keywords CppTypeKeywords.insert("auto"); CppTypeKeywords.insert("bool"); CppTypeKeywords.insert("char"); CppTypeKeywords.insert("char8_t"); CppTypeKeywords.insert("char16_t"); CppTypeKeywords.insert("char32_t"); CppTypeKeywords.insert("double"); CppTypeKeywords.insert("float"); CppTypeKeywords.insert("int"); CppTypeKeywords.insert("long"); CppTypeKeywords.insert("short"); //CppTypeKeywords.insert("signed"); //CppTypeKeywords.insert("unsigned"); CppTypeKeywords.insert("void"); CppTypeKeywords.insert("wchar_t"); CppTypeKeywords.insert("signed"); CppTypeKeywords.insert("unsigned"); // it's part of type info CppKeywords.insert("const",SkipType::skNone); CppKeywords.insert("extern",SkipType::skNone); CppKeywords.insert("inline",SkipType::skNone); // handled elsewhere CppKeywords.insert("class",SkipType::skNone); CppKeywords.insert("enum",SkipType::skNone); CppKeywords.insert("friend",SkipType::skNone); CppKeywords.insert("operator",SkipType::skNone); CppKeywords.insert("private",SkipType::skNone); CppKeywords.insert("protected",SkipType::skNone); CppKeywords.insert("public",SkipType::skNone); CppKeywords.insert("static",SkipType::skNone); CppKeywords.insert("struct",SkipType::skNone); CppKeywords.insert("typedef",SkipType::skNone); CppKeywords.insert("union",SkipType::skNone); // namespace CppKeywords.insert("namespace",SkipType::skNone); CppKeywords.insert("using",SkipType::skNone); CppKeywords.insert("for",SkipType::skNone); CppKeywords.insert("catch",SkipType::skNone); // nullptr is value CppKeywords.insert("nullptr",SkipType::skNone); //C Keywords CKeywords.insert("auto"); CKeywords.insert("break"); CKeywords.insert("case"); CKeywords.insert("char"); CKeywords.insert("const"); CKeywords.insert("continue"); CKeywords.insert("default"); CKeywords.insert("do"); CKeywords.insert("double"); CKeywords.insert("else"); CKeywords.insert("enum"); CKeywords.insert("extern"); CKeywords.insert("float"); CKeywords.insert("for"); CKeywords.insert("goto"); CKeywords.insert("if"); CKeywords.insert("inline"); CKeywords.insert("int"); CKeywords.insert("long"); CKeywords.insert("register"); CKeywords.insert("restrict"); CKeywords.insert("return"); CKeywords.insert("short"); CKeywords.insert("signed"); CKeywords.insert("sizeof"); CKeywords.insert("static"); CKeywords.insert("struct"); CKeywords.insert("switch"); CKeywords.insert("typedef"); CKeywords.insert("union"); CKeywords.insert("unsigned"); CKeywords.insert("void"); CKeywords.insert("volatile"); CKeywords.insert("while"); //STL Containers STLContainers.insert("std::array"); STLContainers.insert("std::vector"); STLContainers.insert("std::deque"); STLContainers.insert("std::forward_list"); STLContainers.insert("std::list"); STLContainers.insert("std::set"); STLContainers.insert("std::map"); STLContainers.insert("std::multilist"); STLContainers.insert("std::multimap"); STLContainers.insert("std::unordered_set"); STLContainers.insert("std::unordered_map"); STLContainers.insert("std::unordered_multiset"); STLContainers.insert("std::unordered_multimap"); STLContainers.insert("std::stack"); STLContainers.insert("std::queue"); STLContainers.insert("std::priority_queue"); STLContainers.insert("std::span"); //STL element access methods STLElementMethods.insert("at"); STLElementMethods.insert("back"); STLElementMethods.insert("front"); STLElementMethods.insert("top"); //STL pointers STLPointers.insert("std::unique_ptr"); STLPointers.insert("std::auto_ptr"); STLPointers.insert("std::shared_ptr"); STLPointers.insert("std::weak_ptr"); STLPointers.insert("__gnu_cxx::__normal_iterator"); STLPointers.insert("std::reverse_iterator"); STLPointers.insert("std::iterator"); //C/CPP preprocessor directives CppDirectives.append("#include"); CppDirectives.append("#if"); CppDirectives.append("#ifdef"); CppDirectives.append("#ifndef"); CppDirectives.append("#else"); CppDirectives.append("#elif"); CppDirectives.append("#endif"); CppDirectives.append("#define"); CppDirectives.append("#error"); CppDirectives.append("#pragma"); CppDirectives.append("#line"); // javadoc tags JavadocTags.append("@author"); JavadocTags.append("@code"); JavadocTags.append("@docRoot"); JavadocTags.append("@deprecated"); JavadocTags.append("@exception"); JavadocTags.append("@inheritDoc"); JavadocTags.append("@link"); JavadocTags.append("@linkplain"); JavadocTags.append("@literal"); JavadocTags.append("@param"); JavadocTags.append("@return"); JavadocTags.append("@see"); JavadocTags.append("@serial"); JavadocTags.append("@serialData"); JavadocTags.append("@serialField"); JavadocTags.append("@since"); JavadocTags.append("@throws"); JavadocTags.append("@value"); JavadocTags.append("@version"); } QString getHeaderFilename(const QString &relativeTo, const QString &line, const QStringList& includePaths, const QStringList& projectIncludePaths) { QString result = ""; // Handle <> int openTokenPos = line.indexOf('<'); if (openTokenPos >= 0) { int closeTokenPos = line.indexOf('>',openTokenPos+1); if (closeTokenPos >=0) { QString fileName = line.mid(openTokenPos + 1, closeTokenPos - openTokenPos - 1); //project settings is preferred result = getSystemHeaderFilename(fileName, projectIncludePaths); if (result.isEmpty()) { result = getSystemHeaderFilename(fileName, includePaths); } } } else { // Try "" openTokenPos = line.indexOf('"'); if (openTokenPos >= 0) { int closeTokenPos = line.indexOf('"', openTokenPos+1); if (closeTokenPos >= 0) { QString fileName = line.mid(openTokenPos + 1, closeTokenPos - openTokenPos - 1); result = getLocalHeaderFilename(relativeTo, fileName); //project settings is preferred if (result.isEmpty()) { result = getSystemHeaderFilename(fileName, projectIncludePaths); } if (result.isEmpty()) { result = getSystemHeaderFilename(fileName, includePaths); } } } } return result; } QString getLocalHeaderFilename(const QString &relativeTo, const QString &fileName) { QFileInfo relativeFile(relativeTo); QDir dir = relativeFile.dir(); // Search local directory if (dir.exists(fileName)) { return dir.absoluteFilePath(fileName); } return ""; } QString getSystemHeaderFilename(const QString &fileName, const QStringList& includePaths) { // Search compiler include directories for (const QString& path:includePaths) { QDir dir(path); if (dir.exists(fileName)) return dir.absoluteFilePath(fileName); } //not found return ""; } bool isSystemHeaderFile(const QString &fileName, const QSet &includePaths) { if (fileName.isEmpty()) return false; if (includePaths.isEmpty()) return false; bool isFullName = false; #ifdef Q_OS_WIN isFullName = fileName.length()>2 && fileName[1]==':'; #else isFullName = fileName.startsWith("\""); #endif if (isFullName) { // If it's a full file name, check if its directory is an include path QFileInfo info(fileName); if (info.exists()) { // full file name QDir dir = info.dir(); QString absPath = includeTrailingPathDelimiter(dir.absolutePath()); foreach (const QString& incPath, includePaths) { if (absPath.startsWith(incPath)) return true; } } } else { //check if it's in the include dir for (const QString& includePath: includePaths) { QDir dir(includePath); if (dir.exists(fileName)) return true; } } return false; } bool isKeyword(const QString &word) { return CppKeywords.contains(word); } bool isHfile(const QString& filename) { if (filename.isEmpty()) return false; QFileInfo fileInfo(filename); return CppHeaderExts->contains(fileInfo.suffix().toLower()); } bool isCfile(const QString& filename) { if (filename.isEmpty()) return false; QFileInfo fileInfo(filename); return CppSourceExts->contains(fileInfo.suffix().toLower()); } PStatement CppScopes::findScopeAtLine(int line) { if (mScopes.isEmpty()) return PStatement(); int start = 0; int end = mScopes.size()-1; while (start<=end) { int mid = (start+end)/2; PCppScope midScope = mScopes[mid]; if (midScope->startLine == line) { while (mid-1>=0 && (mScopes[mid-1]->startLine == line)) { mid--; } return mScopes[mid]->statement; } else if (midScope->startLine > line) { end = mid-1; } else { start = mid+1; } } if (end>=0) return mScopes[end]->statement; else return PStatement(); } void CppScopes::addScope(int line, PStatement scopeStatement) { PCppScope scope = std::make_shared(); scope->startLine = line; scope->statement = scopeStatement; mScopes.append(scope); if (!mScopes.isEmpty() && mScopes.back()->startLine>line) { qDebug()<fullName, line,mScopes.back()->startLine>line); } } PStatement CppScopes::lastScope() { if (mScopes.isEmpty()) return PStatement(); return mScopes.back()->statement; } void CppScopes::removeLastScope() { if (!mScopes.isEmpty()) mScopes.pop_back(); } void CppScopes::clear() { mScopes.clear(); } MemberOperatorType getOperatorType(const QString &phrase, int index) { if (index>=phrase.length()) return MemberOperatorType::otOther; if (phrase[index] == '.') return MemberOperatorType::otDot; if (index+1>=phrase.length()) return MemberOperatorType::otOther; if ((phrase[index] == '-') && (phrase[index+1] == '>')) return MemberOperatorType::otArrow; if ((phrase[index] == ':') && (phrase[index+1] == ':')) return MemberOperatorType::otDColon; return MemberOperatorType::otOther; } bool isScopeTypeKind(StatementKind kind) { switch(kind) { case StatementKind::skClass: case StatementKind::skNamespace: case StatementKind::skFunction: case StatementKind::skConstructor: case StatementKind::skDestructor: return true; default: return false; } } EvalStatement::EvalStatement( const QString &baseType, EvalStatementKind kind, const PStatement &baseStatement, const PStatement &typeStatement, int pointerLevel) { this->baseType = baseType; this->kind = kind; this->baseStatement = baseStatement; this->effectiveTypeStatement = typeStatement; this->pointerLevel = pointerLevel; } void EvalStatement::assignType(const PEvalStatement &typeStatement) { Q_ASSERT(typeStatement && typeStatement->kind==EvalStatementKind::Type); baseType = typeStatement->baseType; pointerLevel = typeStatement->pointerLevel; effectiveTypeStatement = typeStatement->effectiveTypeStatement; }