rabix
/
RedPanda-CPP
mirror of https://github.com/Reduced-panda/RedPanda-CPP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
RedPanda-CPP/RedPandaIDE/parser/parserutils.cpp

635 lines
21 KiB
C++
Raw Blame History

/*
* Copyright (C) 2020-2022 Roy Qu (royqh1979@gmail.com)
*
* 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 <https://www.gnu.org/licenses/>.
*/
#include "parserutils.h"
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QDebug>
#include <QGlobalStatic>
#include "../utils.h"
QStringList CppDirectives;
QStringList JavadocTags;
QMap<QString,SkipType> CppKeywords;
QSet<QString> CppControlKeyWords;
QSet<QString> CppTypeKeywords;
QSet<QString> CKeywords;
QSet<QString> STLPointers;
QSet<QString> STLContainers;
QSet<QString> STLElementMethods;
QSet<QString> MemberOperators;
Q_GLOBAL_STATIC(QSet<QString>,CppHeaderExts)
Q_GLOBAL_STATIC(QSet<QString>,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");
CppControlKeyWords.insert("for");
CppControlKeyWords.insert("if");
CppControlKeyWords.insert("catch");
//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");
CppDirectives.append("#undef");
// 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");
MemberOperators.insert(".");
MemberOperators.insert("::");
MemberOperators.insert("->");
MemberOperators.insert("->*");
MemberOperators.insert(".*");
}
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<QString> &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 isCppKeyword(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<CppScope>();
scope->startLine = line;
scope->statement = scopeStatement;
mScopes.append(scope);
if (!mScopes.isEmpty() && mScopes.back()->startLine>line) {
qDebug()<<QString("Error: new scope %1 at %2 which is less that last scope %3")
.arg(scopeStatement->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::skEnumType:
case StatementKind::skEnumClassType:
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;
}
QStringList getOwnerExpressionAndMember(const QStringList expression, QString &memberOperator, QStringList &memberExpression)
{
//find position of the last member operator
int lastMemberOperatorPos = -1;
int currentMatchingLevel = 0;
QString matchingSignLeft;
QString matchingSignRight;
for (int i=0;i<expression.length();i++) {
QString token = expression[i];
if (currentMatchingLevel == 0) {
if (isMemberOperator(token)) {
lastMemberOperatorPos = i;
} else if (token == "(") {
matchingSignLeft = "(";
matchingSignRight = ")";
currentMatchingLevel++;
} else if (token == "[") {
matchingSignLeft = "[";
matchingSignRight = "]";
currentMatchingLevel++;
} else if (token == "<") {
matchingSignLeft = "<";
matchingSignRight = ">";
currentMatchingLevel++;
}
} else {
if (token == matchingSignLeft) {
currentMatchingLevel++;
} else if (token == matchingSignRight) {
currentMatchingLevel--;
}
}
}
QStringList ownerExpression;
if (lastMemberOperatorPos<0) {
memberOperator = "";
memberExpression = expression;
} else {
memberOperator = expression[lastMemberOperatorPos];
memberExpression = expression.mid(lastMemberOperatorPos+1);
ownerExpression = expression.mid(0,lastMemberOperatorPos);
}
if (memberExpression.length()>1) {
memberExpression = memberExpression.mid(memberExpression.length()-1,1);
}
return ownerExpression;
}
bool isMemberOperator(QString token)
{
return MemberOperators.contains(token);
}
StatementKind getKindOfStatement(const PStatement& statement)
{
if (!statement)
return StatementKind::skUnknown;
if (statement->kind == StatementKind::skVariable) {
if (!statement->parentScope.lock()) {
return StatementKind::skGlobalVariable;
} else if (statement->scope == StatementScope::ssLocal) {
return StatementKind::skLocalVariable;
} else {
return StatementKind::skVariable;
}
}
return statement->kind;
}
bool isCppFile(const QString &filename)
{
if (isCFile(filename) && !filename.endsWith(".c"))
return true;
return false;
}
bool isCppControlKeyword(const QString &word)
{
return CppControlKeyWords.contains(word);
}
Reference in New Issue View Git Blame Copy Permalink