From ab9aa75d1f00603ff1b5dff980f157bf2728a3c8 Mon Sep 17 00:00:00 2001 From: Roy Qu Date: Tue, 1 Nov 2022 09:02:17 +0800 Subject: [PATCH] work save --- RedPandaIDE/iconsmanager.cpp | 18 +- RedPandaIDE/parser/cppparser.cpp | 382 ++++++++++++-------- RedPandaIDE/parser/cppparser.h | 32 +- RedPandaIDE/parser/parserutils.cpp | 212 +++++------ RedPandaIDE/parser/parserutils.h | 61 ++-- RedPandaIDE/widgets/classbrowser.cpp | 2 +- RedPandaIDE/widgets/codecompletionpopup.cpp | 20 +- 7 files changed, 401 insertions(+), 326 deletions(-) diff --git a/RedPandaIDE/iconsmanager.cpp b/RedPandaIDE/iconsmanager.cpp index 82173d20..a0c7ba35 100644 --- a/RedPandaIDE/iconsmanager.cpp +++ b/RedPandaIDE/iconsmanager.cpp @@ -296,18 +296,18 @@ QPixmap IconsManager::getPixmapForStatement(PStatement statement) case StatementKind::skFunction: case StatementKind::skConstructor: case StatementKind::skDestructor: - if (statement->scope == StatementScope::ssGlobal) + if (statement->scope == StatementScope::Global) return *(pIconsManager->getPixmap(IconsManager::PARSER_GLOBAL_METHOD)); if (statement->isInherited) { - if (statement->classScope == StatementClassScope::scsProtected) { + if (statement->classScope == StatementClassScope::Protected) { return *(pIconsManager->getPixmap(IconsManager::PARSER_INHERITED_PROTECTED_METHOD)); - } else if (statement->classScope == StatementClassScope::scsPublic) { + } else if (statement->classScope == StatementClassScope::Public) { return *(pIconsManager->getPixmap(IconsManager::PARSER_INHERITED_METHOD)); } } else { - if (statement->classScope == StatementClassScope::scsProtected) { + if (statement->classScope == StatementClassScope::Protected) { return *(pIconsManager->getPixmap(IconsManager::PARSER_PROTECTED_METHOD)); - } else if (statement->classScope == StatementClassScope::scsPublic) { + } else if (statement->classScope == StatementClassScope::Public) { return *(pIconsManager->getPixmap(IconsManager::PARSER_PUBLIC_METHOD)); } else { return *(pIconsManager->getPixmap(IconsManager::PARSER_PRIVATE_METHOD)); @@ -320,15 +320,15 @@ QPixmap IconsManager::getPixmapForStatement(PStatement statement) return *(pIconsManager->getPixmap(IconsManager::PARSER_LOCAL_VAR)); case StatementKind::skVariable: if (statement->isInherited) { - if (statement->classScope == StatementClassScope::scsProtected) { + if (statement->classScope == StatementClassScope::Protected) { return *(pIconsManager->getPixmap(IconsManager::PARSER_INHERITED_PROTECTD_VAR)); - } else if (statement->classScope == StatementClassScope::scsPublic) { + } else if (statement->classScope == StatementClassScope::Public) { return *(pIconsManager->getPixmap(IconsManager::PARSER_INHERITED_VAR)); } } else { - if (statement->classScope == StatementClassScope::scsProtected) { + if (statement->classScope == StatementClassScope::Protected) { return *(pIconsManager->getPixmap(IconsManager::PARSER_PROTECTED_VAR)); - } else if (statement->classScope == StatementClassScope::scsPublic) { + } else if (statement->classScope == StatementClassScope::Public) { return *(pIconsManager->getPixmap(IconsManager::PARSER_PUBLIC_VAR)); } else { return *(pIconsManager->getPixmap(IconsManager::PARSER_PRIVATE_VAR)); diff --git a/RedPandaIDE/parser/cppparser.cpp b/RedPandaIDE/parser/cppparser.cpp index 24873500..8025c9a5 100644 --- a/RedPandaIDE/parser/cppparser.cpp +++ b/RedPandaIDE/parser/cppparser.cpp @@ -913,8 +913,8 @@ void CppParser::parseHardDefines() define->value, -1, StatementKind::skPreprocessor, - StatementScope::ssGlobal, - StatementClassScope::scsNone, + StatementScope::Global, + StatementClassScope::None, true, false); } @@ -992,11 +992,11 @@ bool CppParser::isFileParsed(const QString &filename) QString CppParser::getScopePrefix(const PStatement& statement){ switch (statement->classScope) { - case StatementClassScope::scsPublic: + case StatementClassScope::Public: return "public"; - case StatementClassScope::scsPrivate: + case StatementClassScope::Private: return "private"; - case StatementClassScope::scsProtected: + case StatementClassScope::Protected: return "protected"; default: return ""; @@ -1048,7 +1048,7 @@ QString CppParser::prettyPrintStatement(const PStatement& statement, const QStri case StatementKind::skVariable: case StatementKind::skParameter: case StatementKind::skClass: - if (statement->scope!= StatementScope::ssLocal) + if (statement->scope!= StatementScope::Local) result = getScopePrefix(statement)+ ' '; // public result += statement->type + ' '; // void result += statement->fullName; // A::B::C::Bar @@ -1249,7 +1249,7 @@ PStatement CppParser::addStatement(const PStatement& parent, //result->friends; result->isStatic = isStatic; result->isInherited = false; - if (scope == StatementScope::ssLocal) + if (scope == StatementScope::Local) result->fullName = newCommand; else result->fullName = getFullStatementName(newCommand, parent); @@ -1351,7 +1351,7 @@ PStatement CppParser::addStatement(const PStatement &parent, const QString &file void CppParser::setInheritance(int index, const PStatement& classStatement, bool isStruct) { // Clear it. Assume it is assigned - StatementClassScope lastInheritScopeType = StatementClassScope::scsNone; + StatementClassScope lastInheritScopeType = StatementClassScope::None; // Assemble a list of statements in text form we inherit from while (true) { StatementClassScope inheritScopeType = getClassScope(mTokenizer[index]->text); @@ -1359,7 +1359,7 @@ void CppParser::setInheritance(int index, const PStatement& classStatement, bool if (currentText=='(') { //skip to matching ')' index=mTokenizer[index]->matchIndex; - } else if (inheritScopeType == StatementClassScope::scsNone) { + } else if (inheritScopeType == StatementClassScope::None) { if (currentText.front()!=',' && currentText.front()!=':') { QString basename = currentText; @@ -1429,13 +1429,13 @@ void CppParser::addSoloScopeLevel(PStatement& statement, int line, bool shouldRe // Set new scope if (!statement) - mClassScope = StatementClassScope::scsNone; // {}, namespace or class that doesn't exist + mClassScope = StatementClassScope::None; // {}, namespace or class that doesn't exist else if (statement->kind == StatementKind::skNamespace) - mClassScope = StatementClassScope::scsNone; + mClassScope = StatementClassScope::None; else if (statement->type == "class") - mClassScope = StatementClassScope::scsPrivate; // classes are private by default + mClassScope = StatementClassScope::Private; // classes are private by default else - mClassScope = StatementClassScope::scsPublic; // structs are public by default + mClassScope = StatementClassScope::Public; // structs are public by default mCurrentClassScope.append(mClassScope); } @@ -1468,7 +1468,7 @@ void CppParser::removeScopeLevel(int line) } if (!currentScope) { - mClassScope = StatementClassScope::scsNone; + mClassScope = StatementClassScope::None; } else { mClassScope = mCurrentClassScope.back(); } @@ -1479,7 +1479,7 @@ void CppParser::internalClear() mCurrentScope.clear(); mCurrentClassScope.clear(); mIndex = 0; - mClassScope = StatementClassScope::scsNone; + mClassScope = StatementClassScope::None; mSkipList.clear(); mBlockBeginSkips.clear(); mBlockEndSkips.clear(); @@ -1543,21 +1543,22 @@ QStringList CppParser::sortFilesByIncludeRelations(const QSet &files) return result; } -bool CppParser::checkForKeyword(SkipType& skipType) +bool CppParser::checkForKeyword(KeywordType& keywordType) { - skipType = mCppKeywords.value(mTokenizer[mIndex]->text,SkipType::skNone); - switch(skipType) { - case SkipType::skCatch: - case SkipType::skFor: - case SkipType::skNone: - case SkipType::skScope: - case SkipType::skEnum: - case SkipType::skInline: - case SkipType::skNamespace: - case SkipType::skTypedef: - case SkipType::skUsing: - case SkipType::skFriend: - case SkipType::skProtected: + keywordType = mCppKeywords.value(mTokenizer[mIndex]->text,KeywordType::None); + switch(keywordType) { + case KeywordType::Catch: + case KeywordType::For: + case KeywordType::None: + case KeywordType::Public: + case KeywordType::Private: + case KeywordType::Enum: + case KeywordType::Inline: + case KeywordType::Namespace: + case KeywordType::Typedef: + case KeywordType::Using: + case KeywordType::Friend: + case KeywordType::Protected: return false; default: return true; @@ -1565,7 +1566,7 @@ bool CppParser::checkForKeyword(SkipType& skipType) } bool CppParser::checkForMethod(QString &sType, QString &sName, int &argStartIndex, - int &argEndIndex, , bool &isStatic, bool &isFriend) + int &argEndIndex, bool &isStatic, bool &isFriend) { PStatement scope = getCurrentScope(); @@ -1624,7 +1625,7 @@ bool CppParser::checkForMethod(QString &sType, QString &sName, int &argStartInde bTypeOK = !sType.isEmpty(); bNameOK = !sName.isEmpty(); bArgsOK = true; - mIndex = argEndIndex; + mIndex = argEndIndex+1; // Allow constructor/destructor too if (!bTypeOK) { @@ -1654,7 +1655,7 @@ bool CppParser::checkForMethod(QString &sType, QString &sName, int &argStartInde } else { //if IsValidIdentifier(mTokenizer[mIndex]->text) then // Still walking through type - QString s = mTokenizer[mIndex]->text; //todo: do we really need expand macro? it should be done in preprocessor + QString s = mTokenizer[mIndex]->text; if (s == "static") isStatic = true; if (s == "friend") @@ -1666,22 +1667,22 @@ bool CppParser::checkForMethod(QString &sType, QString &sName, int &argStartInde mIndex++; } - mIndex = indexBackup; - // Correct function, don't jump over if (bTypeOK && bNameOK && bArgsOK) { sType = sType.trimmed(); // should contain type "int" sName = sName.trimmed(); // should contain function name "foo::function" return true; - } else + } else { + mIndex = indexBackup; return false; + } } -bool CppParser::checkForNamespace(SkipType skipType) +bool CppParser::checkForNamespace(KeywordType keywordType) { - return (skipType==SkipType::skNamespace &&(mIndex < mTokenizer.tokenCount()-1)) + return (keywordType==KeywordType::Namespace &&(mIndex < mTokenizer.tokenCount()-1)) || ( - skipType==SkipType::skInline + keywordType==KeywordType::Inline && (mIndex+1 < mTokenizer.tokenCount()-1) &&mTokenizer[mIndex+1]->text == "namespace" ); @@ -1689,14 +1690,13 @@ bool CppParser::checkForNamespace(SkipType skipType) bool CppParser::checkForPreprocessor() { -// return (mIndex < mTokenizer.tokenCount()) -// && ( "#" == mTokenizer[mIndex]->text); return (mTokenizer[mIndex]->text.startsWith('#')); } -bool CppParser::checkForScope(SkipType skipType) +bool CppParser::checkForScope(KeywordType keywordType) { - return ( (skipType == SkipType::skScope || skipType == SkipType::skProtected) + return ( (keywordType == KeywordType::Public || keywordType == KeywordType::Protected + || keywordType == KeywordType::Private) && mIndex+1 < mTokenizer.tokenCount() && mTokenizer[mIndex + 1]->text == ':' ); @@ -1706,18 +1706,21 @@ void CppParser::checkForSkipStatement() { if ((mSkipList.count()>0) && (mIndex == mSkipList.back())) { // skip to next ';' do { - mIndex++; + if (isLeftParenthesis(mTokenizer[mIndex]->text)) + mIndex=mTokenizer[mIndex]->matchIndex+1; + else + mIndex++; } while ((mIndex < mTokenizer.tokenCount()) && (mTokenizer[mIndex]->text[0] != ';')); mIndex++; //skip ';' mSkipList.pop_back(); } } -bool CppParser::checkForStructs(SkipType skipType) +bool CppParser::checkForStructs(KeywordType keywordType) { int dis = 0; - if (skipType == SkipType::skFriend - || skipType == SkipType::skScope) + if (keywordType == KeywordType::Friend + || keywordType == KeywordType::Scope) dis = 1; if (mIndex >= mTokenizer.tokenCount() - 2 - dis) return false; @@ -1787,9 +1790,9 @@ bool CppParser::checkForTypedefStruct() return (word.length() == keyLen) || isSpaceChar(word[keyLen]) || word[keyLen]=='['; } -bool CppParser::checkForUsing(SkipType skipType) +bool CppParser::checkForUsing(KeywordType keywordType) { - return skipType==SkipType::skUsing == (mIndex < mTokenizer.tokenCount()-1); + return keywordType==KeywordType::Using && (mIndex < mTokenizer.tokenCount()-1); } @@ -1801,13 +1804,13 @@ bool CppParser::checkForVar(bool& isFunctionPointer) // Store old index int indexBackup = mIndex; - SkipType skipType; + KeywordType keywordType; // Use mIndex so we can reuse checking functions if (mIndex + 1 < mTokenizer.tokenCount()) { // Check the current and the next token for (int i = 0; i<=1; i++) { - if (checkForKeyword(skipType) + if (checkForKeyword(keywordType) || isInvalidVarPrefixChar(mTokenizer[mIndex]->text.front()) || (mTokenizer[mIndex]->text.back() == '.') || ( @@ -1846,7 +1849,7 @@ bool CppParser::checkForVar(bool& isFunctionPointer) while (mIndex < mTokenizer.tokenCount()) { if (mTokenizer[mIndex]->text.front() == '#' || mTokenizer[mIndex]->text == '}' - || checkForKeyword(skipType)) { + || checkForKeyword(keywordType)) { break; // fail } else if (mTokenizer[mIndex]->text.front() == ',' || mTokenizer[mIndex]->text.front() == ';' @@ -1963,11 +1966,11 @@ StatementScope CppParser::getScope() // Invalid class or namespace/extern if (!currentScope || (currentScope->kind == StatementKind::skNamespace)) - return StatementScope::ssGlobal; + return StatementScope::Global; else if (currentScope->kind == StatementKind::skClass) - return StatementScope::ssClassLocal; + return StatementScope::ClassLocal; else - return StatementScope::ssLocal; + return StatementScope::Local; } QString CppParser::getStatementKey(const QString &sName, const QString &sType, const QString &sNoNameArgs) @@ -2008,21 +2011,18 @@ void CppParser::handleCatchBlock() if (!((mIndex < mTokenizer.tokenCount()) && (mTokenizer[mIndex]->text.startsWith('(')))) return; //skip params - int i2=mIndex+1; + int i2=mTokenizer[mIndex]->matchIndex+1; if (i2>=mTokenizer.tokenCount()) return; if (mTokenizer[i2]->text.startsWith('{')) { mBlockBeginSkips.append(i2); - int i = skipBraces(i2); - if (i==i2) { - mBlockEndSkips.append(mTokenizer.tokenCount()); - } else { - mBlockEndSkips.append(i); - } + int i = indexOfMatchingBrace(i2); +// if (i==i2) { +// mBlockEndSkips.append(mTokenizer.tokenCount()); +// } else { + mBlockEndSkips.append(i); } else { - int i=i2; - while ((itext.startsWith(';')) - i++; + int i=indexOfNextSemicolon(i2); mBlockEndSkips.append(i); } // add a block @@ -2041,8 +2041,9 @@ void CppParser::handleCatchBlock() true, false); addSoloScopeLevel(block,startLine,false); - if (!mTokenizer[mIndex]->text.contains("...")) - scanMethodArgs(block,mTokenizer[mIndex]->text); + if (!mTokenizer[mIndex+1]->text.contains("...")) + scanMethodArgs(block,mIndex, mTokenizer[mIndex]->matchIndex); + mIndex=mTokenizer[mIndex]->matchIndex+1; } void CppParser::handleEnum() @@ -2061,7 +2062,7 @@ void CppParser::handleEnum() } if ((mIndex< mTokenizer.tokenCount()) && mTokenizer[mIndex]->text.startsWith('{')) { // enum {...} NAME // Skip to the closing brace - int i = skipBraces(mIndex); + int i = indexOfMatchingBrace(mIndex); // Have we found the name? if ((i + 1 < mTokenizer.tokenCount()) && mTokenizer[i]->text.startsWith('}')) { if (!mTokenizer[i + 1]->text.startsWith(';')) @@ -2212,25 +2213,20 @@ void CppParser::handleForBlock() mIndex++; // skip for/catch; if (!(mIndex < mTokenizer.tokenCount())) return; - int i=mIndex; - while ((itext.startsWith(';')) - i++; - if (i>=mTokenizer.tokenCount()) - return; + int i=indexOfNextSemicolon(mIndex); int i2 = i+1; //skip over ';' (tokenizer have change for(;;) to for(;) if (i2>=mTokenizer.tokenCount()) return; if (mTokenizer[i2]->text.startsWith('{')) { mBlockBeginSkips.append(i2); - i=skipBraces(i2); - if (i==i2) - mBlockEndSkips.append(mTokenizer.tokenCount()); - else - mBlockEndSkips.append(i); + i=indexOfMatchingBrace(i2); +// tokenizer will handle unbalanced braces, no need check here +// if (i==i2) +// mBlockEndSkips.append(mTokenizer.tokenCount()); +// else + mBlockEndSkips.append(i); } else { - i=i2; - while ((itext.startsWith(';')) - i++; + i=indexOfNextSemicolon(i2); mBlockEndSkips.append(i); } // add a block @@ -2252,41 +2248,33 @@ void CppParser::handleForBlock() addSoloScopeLevel(block,startLine); } -void CppParser::handleKeyword(SkipType skipType) +void CppParser::handleKeyword(KeywordType skipType) { // Skip switch (skipType) { - case SkipType::skItself: + case KeywordType::SkipItself: // skip it; mIndex++; break; - case SkipType::skToSemicolon: - // Skip to ; - while (mIndex < mTokenizer.tokenCount() && !mTokenizer[mIndex]->text.startsWith(';')) - mIndex++; - mIndex++;// step over + case KeywordType::SkipAfterSemicolon: + // Skip to ; and over it + mIndex = indexOfNextSemicolon(mIndex)+1; break; - case SkipType::skToColon: - // Skip to : - while (mIndex < mTokenizer.tokenCount() && !mTokenizer[mIndex]->text.startsWith(':')) - mIndex++; + case KeywordType::SkipAfterColon: + // Skip to : and over it + mIndex = indexOfNextColon(mIndex)+1; break; - case SkipType::skToRightParenthesis: - // skip to ) - while (mIndex < mTokenizer.tokenCount() && mTokenizer[mIndex]->text!=')') - mIndex++; - mIndex++; // step over + case KeywordType::SkipAfterParenthesis: + // skip pass () + mIndex = indexPassParenthesis(mIndex); break; - case SkipType::skToLeftBrace: + case KeywordType::SkipToLeftBrace: // Skip to { - while (mIndex < mTokenizer.tokenCount() && mTokenizer[mIndex]->text!='{') - mIndex++; + mIndex = indexOfNextLeftBrace(mIndex); break; - case SkipType::skToRightBrace: - // Skip to } - while (mIndex < mTokenizer.tokenCount() && mTokenizer[mIndex]->text!='}') - mIndex++; - mIndex++; // step over + case KeywordType::SkipAfterBrace: + // Skip pass {} + mIndex = indexPassBraces(mIndex); break; default: break; @@ -2300,12 +2288,6 @@ void CppParser::handleMethod(const QString &sType, const QString &sName, int arg int i = mIndex; int startLine = mTokenizer[mIndex]->line; - // Skip over argument list - while ((mIndex < mTokenizer.tokenCount()) && ! ( - isblockChar(mTokenizer[mIndex]->text.front()) - || mTokenizer[mIndex]->text.startsWith(':'))) - mIndex++; - if (mIndex >= mTokenizer.tokenCount()) // not finished define, just skip it; return; @@ -2395,8 +2377,8 @@ void CppParser::handleMethod(const QString &sType, const QString &sName, int arg "", startLine, StatementKind::skVariable, - StatementScope::ssLocal, - StatementClassScope::scsNone, + StatementScope::Local, + StatementClassScope::None, true, false); } @@ -2411,8 +2393,8 @@ void CppParser::handleMethod(const QString &sType, const QString &sName, int arg "\""+scopelessName+"\"", startLine+1, StatementKind::skVariable, - StatementScope::ssLocal, - StatementClassScope::scsNone, + StatementScope::Local, + StatementClassScope::None, true, false); } else { @@ -2448,20 +2430,14 @@ void CppParser::handleMethod(const QString &sType, const QString &sName, int arg mIndex++; } - if (i == mIndex) { // if not moved ahead, something is wrong but don't get stuck ;) - if ( (mIndex < mTokenizer.tokenCount()) && - ! isBraceChar(mTokenizer[mIndex]->text.front())) { - mIndex++; - } - } } -void CppParser::handleNamespace(SkipType skipType) +void CppParser::handleNamespace(KeywordType skipType) { bool isInline=false; int startLine = mTokenizer[mIndex]->line; - if (skipType==SkipType::skInline) { + if (skipType==KeywordType::Inline) { isInline = true; mIndex++; //skip 'inline' } @@ -2510,7 +2486,7 @@ void CppParser::handleNamespace(SkipType skipType) // Skip to '{' while ((mIndextext.front() != '{')) mIndex++; - int i =skipBraces(mIndex); //skip '}' + int i =indexOfMatchingBrace(mIndex); //skip '}' if (i==mIndex) mInlineNamespaceEndSkips.append(mTokenizer.tokenCount()); else @@ -2720,8 +2696,8 @@ void CppParser::handlePreprocessor() value, mTokenizer[mIndex]->line, StatementKind::skPreprocessor, - StatementScope::ssGlobal, - StatementClassScope::scsNone, + StatementScope::Global, + StatementClassScope::None, true, false); } // TODO: undef ( define has limited scope) @@ -2732,18 +2708,32 @@ handlePreprocessorEnd: StatementClassScope CppParser::getClassScope(const QString& text) { if (!text.isEmpty() && text[0]=='p') { if (text=="public") - return StatementClassScope::scsPublic; + return StatementClassScope::Public; else if (text=="private") - return StatementClassScope::scsPrivate; + return StatementClassScope::Private; else if (text=="protected") - return StatementClassScope::scsProtected; + return StatementClassScope::Protected; } - return StatementClassScope::scsNone; + return StatementClassScope::None; } -void CppParser::handleScope() +StatementClassScope CppParser::getClassScope(KeywordType keywordType) { - mClassScope = getClassScope(mTokenizer[mIndex]->text); + switch(keywordType) { + case KeywordType::Public: + return StatementClassScope::Public; + case KeywordType::Private: + return StatementClassScope::Private; + case KeywordType::Protected: + return StatementClassScope::Protected; + default: + return StatementClassScope::None; + } +} + +void CppParser::handleScope(KeywordType keywordType) +{ + mClassScope = getClassScope(keywordType); mIndex+=2; // the scope is followed by a ':' } @@ -2755,7 +2745,7 @@ bool CppParser::handleStatement() int idx=getCurrentBlockEndSkip(); int idx2=getCurrentBlockBeginSkip(); int idx3=getCurrentInlineNamespaceEndSkip(); - SkipType skipType; + KeywordType keywordType; bool isFunctionPointer; if (mIndex >= idx2) { //skip (previous handled) block begin @@ -2799,17 +2789,17 @@ bool CppParser::handleStatement() mIndex++; } else if (checkForPreprocessor()) { handlePreprocessor(); - } else if (checkForKeyword(skipType)) { // includes template now - handleKeyword(skipType); - } else if (skipType==SkipType::skFor) { // (for/catch) + } else if (checkForKeyword(keywordType)) { // includes template now + handleKeyword(keywordType); + } else if (keywordType==KeywordType::For) { // (for/catch) handleForBlock(); - } else if (skipType==SkipType::skCatch) { // (for/catch) + } else if (keywordType==KeywordType::Catch) { // (for/catch) handleCatchBlock(); - } else if (checkForScope(skipType)) { // public /private/proteced - handleScope(); - } else if (skipType==SkipType::skEnum) { + } else if (checkForScope(keywordType)) { // public /private/proteced + handleScope(keywordType); + } else if (keywordType==KeywordType::Enum) { handleEnum(); - } else if (skipType==SkipType::skTypedef) { + } else if (keywordType==KeywordType::Typedef) { if (mIndex+1 < mTokenizer.tokenCount()) { if (checkForTypedefStruct()) { // typedef struct something mIndex++; // skip 'typedef' @@ -2821,11 +2811,11 @@ bool CppParser::handleStatement() handleOtherTypedefs(); // typedef Foo Bar } else mIndex++; - } else if (checkForNamespace(skipType)) { - handleNamespace(skipType); - } else if (checkForUsing(skipType)) { + } else if (checkForNamespace(keywordType)) { + handleNamespace(keywordType); + } else if (checkForUsing(keywordType)) { handleUsing(); - } else if (checkForStructs(skipType)) { + } else if (checkForStructs(keywordType)) { handleStructs(false); } else if (checkForMethod(funcType, funcName, argStart,argEnd, isStatic, isFriend)) { handleMethod(funcType, funcName, argStart, argEnd, isStatic, isFriend); // don't recalculate parts @@ -2989,7 +2979,7 @@ void CppParser::handleStructs(bool isTypedef) if (isStruct) { // Walk to closing brace - i = skipBraces(mIndex); // step onto closing brace + i = indexOfMatchingBrace(mIndex); // step onto closing brace if ((i + 1 < mTokenizer.tokenCount()) && !( mTokenizer[i + 1]->text.front() == ';' @@ -3358,7 +3348,7 @@ void CppParser::handleVar(bool isFunctionPointer) if (varAdded && (mIndex < mTokenizer.tokenCount()) && (mTokenizer[mIndex]->text == '{')) { // skip { } like A x {new A}; - int i=skipBraces(mIndex); + int i=indexOfMatchingBrace(mIndex); if (i!=mIndex) mIndex = i+1; } @@ -3432,30 +3422,30 @@ void CppParser::inheritClassStatement(const PStatement& derived, bool isStruct, const PStatement& base, StatementClassScope access) { //differentiate class and struct - if (access == StatementClassScope::scsNone) { + if (access == StatementClassScope::None) { if (isStruct) - access = StatementClassScope::scsPublic; + access = StatementClassScope::Public; else - access = StatementClassScope::scsPrivate; + access = StatementClassScope::Private; } foreach (const PStatement& statement, base->children) { - if (statement->classScope == StatementClassScope::scsPrivate + if (statement->classScope == StatementClassScope::Private || statement->kind == StatementKind::skConstructor || statement->kind == StatementKind::skDestructor) continue; StatementClassScope m_acc; switch(access) { - case StatementClassScope::scsPublic: + case StatementClassScope::Public: m_acc = statement->classScope; break; - case StatementClassScope::scsProtected: - m_acc = StatementClassScope::scsProtected; + case StatementClassScope::Protected: + m_acc = StatementClassScope::Protected; break; - case StatementClassScope::scsPrivate: - m_acc = StatementClassScope::scsPrivate; + case StatementClassScope::Private: + m_acc = StatementClassScope::Private; break; default: - m_acc = StatementClassScope::scsPrivate; + m_acc = StatementClassScope::Private; } //inherit addInheritedStatement(derived,statement,m_acc); @@ -4495,8 +4485,8 @@ void CppParser::scanMethodArgs(const PStatement& functionStatement, int argStart "", functionStatement->definitionLine, StatementKind::skParameter, - StatementScope::ssLocal, - StatementClassScope::scsNone, + StatementScope::Local, + StatementClassScope::None, true, false); } @@ -4658,7 +4648,7 @@ void CppParser::scanMethodArgs(const PStatement& functionStatement, int argStart if (varAdded && (mIndex < mTokenizer.tokenCount()) && (mTokenizer[mIndex]->text == '{')) { // skip { } like A x {new A}; - int i=skipBraces(mIndex); + int i=indexOfMatchingBrace(mIndex); if (i!=mIndex) mIndex = i+1; } @@ -4918,6 +4908,80 @@ void CppParser::updateSerialId() mSerialId = QString("%1 %2").arg(mParserId).arg(mSerialCount); } +int CppParser::indexOfNextSemicolon(int index) +{ + while (indextext[0].unicode()) { + case ';': + return index; + case '(': + index = mTokenizer[index]->matchIndex+1; + break; + default: + index++; + } + } + return index; +} + +int CppParser::indexOfNextColon(int index) +{ + while (indextext[0].unicode()) { + case ':': + return index; + case '(': + index = mTokenizer[index]->matchIndex+1; + break; + default: + index++; + } + } + return index; +} + +int CppParser::indexOfNextLeftBrace(int index) +{ + while (indextext[0].unicode()) { + case '{': + return index; + case '(': + index = mTokenizer[index]->matchIndex+1; + break; + default: + index++; + } + } + return index; +} + +int CppParser::indexPassParenthesis(int index) +{ + while (indextext=='(') { + return mTokenizer[index]->matchIndex+1; + } + } + return index; +} + +int CppParser::indexPassBraces(int index) +{ + while (indextext[0].unicode()) { + case '{': + return mTokenizer[index]->matchIndex+1; + case '(': + index = mTokenizer[index]->matchIndex+1; + break; + default: + index++; + } + } + return index; +} + ParserLanguage CppParser::language() const { return mLanguage; diff --git a/RedPandaIDE/parser/cppparser.h b/RedPandaIDE/parser/cppparser.h index 0424d985..2cefe5ed 100644 --- a/RedPandaIDE/parser/cppparser.h +++ b/RedPandaIDE/parser/cppparser.h @@ -200,7 +200,8 @@ private: bool isCurrentScope(const QString& command); void addSoloScopeLevel(PStatement& statement, int line, bool shouldResetBlock = true); // adds new solo level void removeScopeLevel(int line); // removes level - int skipBraces(int startAt) { + + int indexOfMatchingBrace(int startAt) { return mTokenizer[startAt]->matchIndex; } @@ -208,17 +209,17 @@ private: QStringList sortFilesByIncludeRelations(const QSet &files); - bool checkForKeyword(SkipType &skipType); + bool checkForKeyword(KeywordType &keywordType); bool checkForMethod(QString &sType, QString &sName, int &argStartIndex, int &argEndIndex, bool &isStatic, bool &isFriend); // caching of results - bool checkForNamespace(SkipType skipType); + bool checkForNamespace(KeywordType keywordType); bool checkForPreprocessor(); - bool checkForScope(SkipType skipType); + bool checkForScope(KeywordType keywordType); void checkForSkipStatement(); - bool checkForStructs(SkipType skipType); + bool checkForStructs(KeywordType keywordType); bool checkForTypedefEnum(); bool checkForTypedefStruct(); - bool checkForUsing(SkipType skipType); + bool checkForUsing(KeywordType keywordType); bool checkForVar(bool& isFunctionPointer); void fillListOfFunctions(const QString& fileName, int line, @@ -356,6 +357,7 @@ private: int getBracketEnd(const QString& s, int startAt); StatementClassScope getClassScope(const QString& text); + StatementClassScope getClassScope(KeywordType keywordType); int getCurrentBlockBeginSkip(); int getCurrentBlockEndSkip(); int getCurrentInlineNamespaceEndSkip(); @@ -384,7 +386,7 @@ private: void handleCatchBlock(); void handleEnum(); void handleForBlock(); - void handleKeyword(SkipType skipType); + void handleKeyword(KeywordType skipType); void handleMethod( const QString& sType, const QString& sName, @@ -392,10 +394,10 @@ private: int argEnd, bool isStatic, bool isFriend); - void handleNamespace(SkipType skipType); + void handleNamespace(KeywordType skipType); void handleOtherTypedefs(); void handlePreprocessor(); - void handleScope(); + void handleScope(KeywordType keywordType); bool handleStatement(); void handleStructs(bool isTypedef = false); void handleUsing(); @@ -465,6 +467,10 @@ private: } } + bool isLeftParenthesis(const QString& text) const { + return text=="("; + } + /*';', '{', '}'*/ bool isblockChar(const QChar& ch) const { switch(ch.unicode()){ @@ -525,7 +531,11 @@ private: void updateSerialId(); - + int indexOfNextSemicolon(int index); + int indexOfNextColon(int index); + int indexOfNextLeftBrace(int index); + int indexPassParenthesis(int index); + int indexPassBraces(int index); private: int mParserId; ParserLanguage mLanguage; @@ -568,7 +578,7 @@ private: QMutex mMutex; GetFileStreamCallBack mOnGetFileStream; - QMap mCppKeywords; + QMap mCppKeywords; QSet mCppTypeKeywords; }; using PCppParser = std::shared_ptr; diff --git a/RedPandaIDE/parser/parserutils.cpp b/RedPandaIDE/parser/parserutils.cpp index dac8315c..718d113c 100644 --- a/RedPandaIDE/parser/parserutils.cpp +++ b/RedPandaIDE/parser/parserutils.cpp @@ -25,7 +25,7 @@ QStringList CppDirectives; QStringList JavadocTags; -QMap CppKeywords; +QMap CppKeywords; QSet CppControlKeyWords; QSet CppTypeKeywords; QSet CKeywords; @@ -55,107 +55,107 @@ void initParser() 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("and",KeywordType::SkipItself); + CppKeywords.insert("and_eq",KeywordType::SkipItself); + CppKeywords.insert("bitand",KeywordType::SkipItself); + CppKeywords.insert("bitor",KeywordType::SkipItself); + CppKeywords.insert("break",KeywordType::SkipItself); + CppKeywords.insert("compl",KeywordType::SkipItself); + CppKeywords.insert("constexpr",KeywordType::SkipItself); + CppKeywords.insert("const_cast",KeywordType::SkipItself); + CppKeywords.insert("continue",KeywordType::SkipItself); + CppKeywords.insert("dynamic_cast",KeywordType::SkipItself); + CppKeywords.insert("else",KeywordType::SkipItself); + CppKeywords.insert("explicit",KeywordType::SkipItself); + CppKeywords.insert("export",KeywordType::SkipItself); + CppKeywords.insert("false",KeywordType::SkipItself); //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("mutable",KeywordType::SkipItself); + CppKeywords.insert("noexcept",KeywordType::SkipItself); + CppKeywords.insert("not",KeywordType::SkipItself); + CppKeywords.insert("not_eq",KeywordType::SkipItself); + CppKeywords.insert("nullptr",KeywordType::SkipItself); + CppKeywords.insert("or",KeywordType::SkipItself); + CppKeywords.insert("or_eq",KeywordType::SkipItself); + CppKeywords.insert("register",KeywordType::SkipItself); + CppKeywords.insert("reinterpret_cast",KeywordType::SkipItself); + CppKeywords.insert("static_assert",KeywordType::SkipItself); + CppKeywords.insert("static_cast",KeywordType::SkipItself); + CppKeywords.insert("template",KeywordType::SkipItself); //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("thread_local",KeywordType::SkipItself); + CppKeywords.insert("true",KeywordType::SkipItself); + CppKeywords.insert("typename",KeywordType::SkipItself); + CppKeywords.insert("virtual",KeywordType::SkipItself); + CppKeywords.insert("volatile",KeywordType::SkipItself); + CppKeywords.insert("xor",KeywordType::SkipItself); + CppKeywords.insert("xor_eq",KeywordType::SkipItself); //CppKeywords.insert("catch",SkipType::skItself); - CppKeywords.insert("do",SkipType::skItself); - CppKeywords.insert("try",SkipType::skItself); + CppKeywords.insert("do",KeywordType::SkipItself); + CppKeywords.insert("try",KeywordType::SkipItself); // 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("delete",KeywordType::SkipAfterSemicolon); + CppKeywords.insert("delete[]",KeywordType::SkipAfterSemicolon); + CppKeywords.insert("goto",KeywordType::SkipAfterSemicolon); + CppKeywords.insert("new",KeywordType::SkipAfterSemicolon); + CppKeywords.insert("return",KeywordType::SkipAfterSemicolon); + CppKeywords.insert("throw",KeywordType::SkipAfterSemicolon); // CppKeywords.insert("using",SkipType::skToSemicolon); //won't use it // Skip to : - CppKeywords.insert("case",SkipType::skToColon); - CppKeywords.insert("default",SkipType::skToColon); + CppKeywords.insert("case",KeywordType::SkipAfterColon); + CppKeywords.insert("default",KeywordType::SkipAfterColon); // 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); + CppKeywords.insert("__attribute__",KeywordType::SkipAfterParenthesis); + CppKeywords.insert("alignas",KeywordType::SkipAfterParenthesis); // not right + CppKeywords.insert("alignof",KeywordType::SkipAfterParenthesis); // not right + CppKeywords.insert("decltype",KeywordType::SkipAfterParenthesis); // not right + CppKeywords.insert("if",KeywordType::SkipAfterParenthesis); + CppKeywords.insert("sizeof",KeywordType::SkipAfterParenthesis); + CppKeywords.insert("switch",KeywordType::SkipAfterParenthesis); + CppKeywords.insert("typeid",KeywordType::SkipAfterParenthesis); + CppKeywords.insert("while",KeywordType::SkipAfterParenthesis); // Skip to } - CppKeywords.insert("asm",SkipType::skToRightBrace); + CppKeywords.insert("asm",KeywordType::SkipAfterBrace); //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); + CppKeywords.insert("atomic_cancel",KeywordType::None); + CppKeywords.insert("atomic_commit",KeywordType::None); + CppKeywords.insert("atomic_noexcept",KeywordType::None); + CppKeywords.insert("concept",KeywordType::None); + CppKeywords.insert("consteval",KeywordType::None); + CppKeywords.insert("constinit",KeywordType::None); + CppKeywords.insert("co_wait",KeywordType::None); + CppKeywords.insert("co_return",KeywordType::None); + CppKeywords.insert("co_yield",KeywordType::None); + CppKeywords.insert("reflexpr",KeywordType::None); + CppKeywords.insert("requires",KeywordType::None); // 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); + CppKeywords.insert("auto",KeywordType::None); + CppKeywords.insert("bool",KeywordType::None); + CppKeywords.insert("char",KeywordType::None); + CppKeywords.insert("char8_t",KeywordType::None); + CppKeywords.insert("char16_t",KeywordType::None); + CppKeywords.insert("char32_t",KeywordType::None); + CppKeywords.insert("double",KeywordType::None); + CppKeywords.insert("float",KeywordType::None); + CppKeywords.insert("int",KeywordType::None); + CppKeywords.insert("long",KeywordType::None); + CppKeywords.insert("short",KeywordType::None); + CppKeywords.insert("signed",KeywordType::None); + CppKeywords.insert("unsigned",KeywordType::None); + CppKeywords.insert("void",KeywordType::None); + CppKeywords.insert("wchar_t",KeywordType::None); // type keywords CppTypeKeywords.insert("auto"); @@ -177,30 +177,30 @@ void initParser() CppTypeKeywords.insert("unsigned"); // it's part of type info - CppKeywords.insert("const",SkipType::skNone); - CppKeywords.insert("extern",SkipType::skNone); + CppKeywords.insert("const",KeywordType::None); + CppKeywords.insert("extern",KeywordType::None); // handled elsewhere - CppKeywords.insert("class",SkipType::skNone); - CppKeywords.insert("operator",SkipType::skNone); - CppKeywords.insert("static",SkipType::skNone); - CppKeywords.insert("struct",SkipType::skNone); - CppKeywords.insert("union",SkipType::skNone); + CppKeywords.insert("class",KeywordType::None); + CppKeywords.insert("operator",KeywordType::None); + CppKeywords.insert("static",KeywordType::None); + CppKeywords.insert("struct",KeywordType::None); + CppKeywords.insert("union",KeywordType::None); - CppKeywords.insert("for",SkipType::skFor); - CppKeywords.insert("catch",SkipType::skCatch); - CppKeywords.insert("private",SkipType::skScope); - CppKeywords.insert("public",SkipType::skScope); - CppKeywords.insert("enum",SkipType::skEnum); - CppKeywords.insert("namespace",SkipType::skNamespace); - CppKeywords.insert("inline",SkipType::skInline); - CppKeywords.insert("typedef",SkipType::skTypedef); - CppKeywords.insert("using",SkipType::skUsing); - CppKeywords.insert("protected",SkipType::skProtected); - CppKeywords.insert("friend",SkipType::skFriend); + CppKeywords.insert("for",KeywordType::For); + CppKeywords.insert("catch",KeywordType::Catch); + CppKeywords.insert("private",KeywordType::Private); + CppKeywords.insert("public",KeywordType::Public); + CppKeywords.insert("enum",KeywordType::Enum); + CppKeywords.insert("namespace",KeywordType::Namespace); + CppKeywords.insert("inline",KeywordType::Inline); + CppKeywords.insert("typedef",KeywordType::Typedef); + CppKeywords.insert("using",KeywordType::Using); + CppKeywords.insert("protected",KeywordType::Protected); + CppKeywords.insert("friend",KeywordType::Friend); // nullptr is value - CppKeywords.insert("nullptr",SkipType::skNone); + CppKeywords.insert("nullptr",KeywordType::None); //C Keywords CKeywords.insert("auto"); @@ -535,16 +535,16 @@ void CppScopes::clear() MemberOperatorType getOperatorType(const QString &phrase, int index) { if (index>=phrase.length()) - return MemberOperatorType::otOther; + return MemberOperatorType::Other; if (phrase[index] == '.') - return MemberOperatorType::otDot; + return MemberOperatorType::Dot; if (index+1>=phrase.length()) - return MemberOperatorType::otOther; + return MemberOperatorType::Other; if ((phrase[index] == '-') && (phrase[index+1] == '>')) - return MemberOperatorType::otArrow; + return MemberOperatorType::Arrow; if ((phrase[index] == ':') && (phrase[index+1] == ':')) - return MemberOperatorType::otDColon; - return MemberOperatorType::otOther; + return MemberOperatorType::DColon; + return MemberOperatorType::Other; } bool isScopeTypeKind(StatementKind kind) @@ -645,7 +645,7 @@ StatementKind getKindOfStatement(const PStatement& statement) if (statement->kind == StatementKind::skVariable) { if (!statement->parentScope.lock()) { return StatementKind::skGlobalVariable; - } else if (statement->scope == StatementScope::ssLocal) { + } else if (statement->scope == StatementScope::Local) { return StatementKind::skLocalVariable; } else { return StatementKind::skVariable; diff --git a/RedPandaIDE/parser/parserutils.h b/RedPandaIDE/parser/parserutils.h index e40e0f7a..8e3c4304 100644 --- a/RedPandaIDE/parser/parserutils.h +++ b/RedPandaIDE/parser/parserutils.h @@ -56,24 +56,25 @@ using PDefine = std::shared_ptr; using DefineMap = QHash; using PDefineMap = std::shared_ptr; -enum class SkipType { - skItself, // skip itself - skToSemicolon, // skip to ; - skToColon, // skip to : - skToRightParenthesis, // skip to ) - skToLeftBrace,// Skip to { - skToRightBrace, // skip to } - skFor, //for - skCatch, //catch - skScope, // public/private - skProtected, - skFriend, - skEnum, //enum - skInline, // inline - skNamespace, //namespace - skTypedef, //typedef - skUsing, //using - skNone // It's a keyword but don't process here +enum class KeywordType { + SkipItself, // skip itself + SkipAfterSemicolon, // skip to ; + SkipAfterColon, // skip to : + SkipAfterParenthesis, // skip to ) + SkipToLeftBrace,// Skip to { + SkipAfterBrace, // skip to } + For, //for + Catch, //catch + Public, // public + Private, + Protected, + Friend, + Enum, //enum + Inline, // inline + Namespace, //namespace + Typedef, //typedef + Using, //using + None // It's a keyword but don't process here }; @@ -104,23 +105,23 @@ enum StatementKind { using StatementKindSet = QSet; enum class StatementScope { - ssGlobal, - ssLocal, - ssClassLocal + Global, + Local, + ClassLocal }; enum class StatementClassScope { - scsNone, - scsPrivate, - scsProtected, - scsPublic + None, + Private, + Protected, + Public }; enum class MemberOperatorType { - otArrow, - otDot, - otDColon, - otOther + Arrow, + Dot, + DColon, + Other }; enum class EvalStatementKind { @@ -242,7 +243,7 @@ using PFileIncludes = std::shared_ptr; extern QStringList CppDirectives; extern QStringList JavadocTags; -extern QMap CppKeywords; +extern QMap CppKeywords; extern QSet CppControlKeyWords; extern QSet CKeywords; extern QSet CppTypeKeywords; diff --git a/RedPandaIDE/widgets/classbrowser.cpp b/RedPandaIDE/widgets/classbrowser.cpp index cc35833f..325b0a34 100644 --- a/RedPandaIDE/widgets/classbrowser.cpp +++ b/RedPandaIDE/widgets/classbrowser.cpp @@ -338,7 +338,7 @@ void ClassBrowserModel::filterChildren(ClassBrowserNode *node, const StatementMa if (statement == node->statement) // prevent infinite recursion continue; - if (statement->scope == StatementScope::ssLocal) + if (statement->scope == StatementScope::Local) continue; if (pSettings->codeCompletion().hideSymbolsStartsWithTwoUnderLine() diff --git a/RedPandaIDE/widgets/codecompletionpopup.cpp b/RedPandaIDE/widgets/codecompletionpopup.cpp index 07bd62c2..0441ae11 100644 --- a/RedPandaIDE/widgets/codecompletionpopup.cpp +++ b/RedPandaIDE/widgets/codecompletionpopup.cpp @@ -278,11 +278,11 @@ static bool sortByScopeComparator(PStatement statement1,PStatement statement2){ if (statement1->inSystemHeader != statement2->inSystemHeader) return !(statement1->inSystemHeader); // Show local statements first - if (statement1->scope != StatementScope::ssGlobal - && statement2->scope == StatementScope::ssGlobal ) { + if (statement1->scope != StatementScope::Global + && statement2->scope == StatementScope::Global ) { return true; - } else if (statement1->scope == StatementScope::ssGlobal - && statement2->scope != StatementScope::ssGlobal ) { + } else if (statement1->scope == StatementScope::Global + && statement2->scope != StatementScope::Global ) { return false; } else return nameComparator(statement1,statement2); @@ -359,11 +359,11 @@ static bool sortByScopeWithUsageComparator(PStatement statement1,PStatement stat if (statement1->inSystemHeader != statement2->inSystemHeader) return !(statement1->inSystemHeader); // Show local statements first - if (statement1->scope != StatementScope::ssGlobal - && statement2->scope == StatementScope::ssGlobal ) { + if (statement1->scope != StatementScope::Global + && statement2->scope == StatementScope::Global ) { return true; - } else if (statement1->scope == StatementScope::ssGlobal - && statement2->scope != StatementScope::ssGlobal ) { + } else if (statement1->scope == StatementScope::Global + && statement2->scope != StatementScope::Global ) { return false; } else return nameComparator(statement1,statement2); @@ -712,7 +712,7 @@ void CodeCompletionPopup::getCompletionFor( if (children.isEmpty()) return; foreach (const PStatement& childStatement, children) { - if ((childStatement->classScope==StatementClassScope::scsPublic) + if ((childStatement->classScope==StatementClassScope::Public) && !( childStatement->kind == StatementKind::skConstructor || childStatement->kind == StatementKind::skDestructor) @@ -769,7 +769,7 @@ void CodeCompletionPopup::getCompletionFor( || childStatement->kind == StatementKind::skEnumClassType || childStatement->kind == StatementKind::skEnumType )) { - if (childStatement->classScope == StatementClassScope::scsPublic) + if (childStatement->classScope == StatementClassScope::Public) addStatement(childStatement,fileName,-1); } }