initcompletion.cpp

用Qt4编写的linux IDE开发环境

            return fd;
        }
    }
    else
    {
        /* relative pathname */
        for (int i = 0; i < cpp_includes.size(); i++)
        {
            fd->setFileName(cpp_includes.at(i) + '/' + filename);
            if (fd->open(QIODevice::ReadOnly))
            {
                fullname = QFileInfo(cpp_includes.at(i) + '/' + filename).canonicalFilePath();
                return fd;
            }
        }
    }

    // Nothing was found
    fd->close();
    delete fd;
    return NULL;
}
//
TagList InitCompletion::readFromDB(TagList list, Expression exp, QString functionName)
{
    if ( exp.className.isEmpty() )
        return TagList();
    QStringList classes;
    classes << exp.className;
    if ( !connectQDevelopDB( getQDevelopPath() + "qdevelop.db" ) )
    {
        return TagList();
    }
    /* The first character is not a 'Q', certainly an class created in the project. We read the list
    from the class browser which have all the classes and members of the project */
    classes = inheritanceList(exp.className, classes);
    const QList<ParsedItem> *itemsList = m_treeClasses->treeClassesItems();
    for (int i = 0; i < itemsList->size(); ++i)
    {
        ParsedItem parsedItem = itemsList->at( i );
        Tag tag;
        tag.access = parsedItem.access;
        tag.name = parsedItem.name;
        tag.parameters = parsedItem.signature;
        tag.signature = parsedItem.signature;
        tag.returned = parsedItem.ex_cmd.section(" ", 0, 0);
        if ( tag.returned.contains("<") )
            tag.returned = tag.returned.section("<", 0, 0);
        if ( parsedItem.kind == "f" )
            tag.kind = "function";
        else if ( parsedItem.kind == "p" )
            tag.kind = "prototype";
        else if ( parsedItem.kind == "c" )
        {
            tag.kind = "class";
            tag.parameters = "";
        }
        else if ( parsedItem.kind == "e" )
        {
            if (  parsedItem.enumname.section(":", 0, 0) != exp.className )
                continue;
            parsedItem.classname = exp.className;
            tag.parameters = "";
            tag.kind = "member";
        }
        else if ( parsedItem.kind == "m" )
        {
            tag.kind = "member";
            tag.parameters = "";
        }
        else if ( parsedItem.kind == "s" )
        {
            tag.kind = "struct";
            tag.parameters = "";
        }
        else
        {
            continue;
        }
        bool isStatic = parsedItem.ex_cmd.simplified().startsWith("static");
        if ( !classes.contains( parsedItem.classname ) 
        	&& !classes.contains( parsedItem.structname )
        	&& !classes.contains( parsedItem.structname.section("::", -1) )
        	 )
            continue;
        else if ( !functionName.isEmpty() && parsedItem.name != functionName )
            continue;
        else if ( parsedItem.name == parsedItem.classname ||  "~"+parsedItem.name == parsedItem.classname )
            continue;
        else if ( tag.access != "public" && !m_text.simplified().endsWith("this->") )
            continue;
        else if ( (exp.access == AccessStatic && isStatic != true && tag.kind != "struct" && tag.kind != "class")
                  || (exp.access != AccessStatic && isStatic == true))
            continue;
        list << tag;
    }
    // Continue the reading in qdevelop.db
    createTables();
    QSqlQuery query(QSqlDatabase::database(getQDevelopPath() + "qdevelop.db" ));
    query.exec("BEGIN TRANSACTION;");
    //
    QString queryString = QString()
                          + "select * from inheritance where child='"+exp.className+"'";
    query.exec(queryString);
    while (query.next())
    {

        QString parent = query.value(0).toString().replace("$", "'");
        if ( !parent.isEmpty() )
        {
            classes << parent;
        }
    }
    //
    queryString = QString()
                  + "select * from tags where class in ( ";
    foreach(QString c, classes)
    {
        queryString = queryString + " '" + c + "',";
    }
    queryString = queryString.left( queryString.length()-1 );
    queryString += " )";
    if ( !functionName.simplified().isEmpty() )
    {
        queryString += " and name='" + functionName + "'";
    }
    //
    query.exec(queryString);
    while (query.next())
    {
        Tag tag;
        tag.name = query.value(1).toString().replace("$", "'");
        tag.parameters = query.value(2).toString().replace("$", "'");
        tag.longName = query.value(3).toString().replace("$", "'");
        tag.kind = query.value(4).toString().replace("$", "'");
        tag.access = query.value(5).toString().replace("$", "'");
        tag.signature = query.value(6).toString().replace("$", "'");
        tag.returned = query.value(7).toString().replace("$", "'");
        tag.isFunction = query.value(8).toInt();
        tag.isStatic = query.value(9).toInt();
        if ( (exp.access == AccessStatic && tag.isStatic != true)
                || (exp.access != AccessStatic && tag.isStatic == true))
            continue;
        else if ( tag.access != "public" && !m_text.simplified().endsWith("this->") )
            continue;
        if ( list.count() && functionName.simplified().isEmpty())
        {
            Tag lastTag = list.last();
            if ( lastTag.name == tag.name )
                list.pop_back();
        }
        list << tag;
    }
    return list;
}
//
bool InitCompletion::connectQDevelopDB(QString const& dbName)
{
    QSqlDatabase database;

    if ( QSqlDatabase::database(dbName).databaseName() != dbName )
    {
        database = QSqlDatabase::addDatabase("QSQLITE", dbName);
        database.setDatabaseName(dbName);
    }
    else
    {
        database = QSqlDatabase::database(dbName);
        if ( database.isOpen() )
            return true;
    }
    //
    if (!database.open())
    {
        emit showMessage(	  QObject::tr("Unable to establish a database connection.")+"\n"+
                              QObject::tr("QDevelop needs SQLite support. Please read "
                                          "the Qt SQL driver documentation for information how "
                                          "to build it.") );
        return false;
    }
    return true;
}
//
void InitCompletion::writeToDB(Expression exp, TagList list, QSqlQuery query)
{
    foreach(Tag tag, list)
    {
        QString queryString = "insert into tags values(";
        queryString = queryString
                      + "'" + exp.className.replace("'", "$") + "', "
                      + "'" + tag.name.replace("'", "$") + "', "
                      + "'" + tag.parameters.replace("'", "$") + "', "
                      + "'" + tag.longName.replace("'", "$") + "', "
                      + "'" + tag.kind.replace("'", "$") + "', "
                      + "'" + tag.access.replace("'", "$") + "', "
                      + "'" + tag.signature.replace("'", "$") + "', "
                      + "'" + tag.returned.replace("'", "$") + "', "
                                        + "'" + QString::number(tag.isFunction) + "', "
                                        + "'" + QString::number(tag.isStatic) + "')";
        bool rc = query.exec(queryString);
        if (rc == false)
        {
            qDebug() << "Failed to insert record to db" << query.lastError();
            qDebug() << queryString;
            return;
        }
    }
}
//
void InitCompletion::createTables()
{
    QString queryString = "create table tags ("
                          "class string,"
                          "name string,"
                          "parameters string,"
                          "longName string,"
                          "kind string,"
                          "access string,"
                          "signature string,"
                          "returned string,"
                          "isFunction int,"
                          "isStatic int"
                          ")";
    QSqlQuery query(QSqlDatabase::database(getQDevelopPath() + "qdevelop.db" ));
    query.exec(queryString);
    //
    queryString = "create table inheritance ("
                  "parent string,"
                  "child string"
                  ")";
    query.exec(queryString);
}
//

QStringList InitCompletion::filesList(QString directory, QStringList files)
{
    QDir dir(directory);
    QString filterNames = "q*.h;Q*.h";
    QFileInfoList list = dir.entryInfoList(filterNames.split(";"), QDir::AllDirs | QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot);
    foreach(QFileInfo fileInfo, list)
    {
        if ( fileInfo.isFile() ) // Header file
        {
            files << fileInfo.absoluteFilePath();
        }
        else // Directory
        {
            files = filesList(fileInfo.absoluteFilePath(), files);
        }
    }
    return files;
}
//
void InitCompletion::populateQtDatabase()
{
   QString command = ctagsCmdPath + " -L "+QDir::tempPath()+"/qdevelopfilenames -f \"" + QDir::tempPath()+"/qttags" +
                      "\" --language-force=c++ --fields=afiKmsSzn --c++-kinds=cdefgmnpstuvx \""
                      + m_qtInclude + '\"';
    QStringList files;
    files = filesList(m_qtInclude, files);
     QFile f(QDir::tempPath()+"/qdevelopfilenames");
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text))
         return;
     f.write( files.join("\n").toAscii() );
    f.close();
    QProcess ctags;
    if( ctags.execute(command) != 0 )
    {
    	emit showMessage( tr("Unable to launch %1").arg(command) );
    	return;
   	}
    ctags.waitForFinished(-1);
    QFile file(QDir::tempPath()+"/qttags");
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
    	emit showMessage( tr("Unable to open %1").arg(QDir::tempPath()+"/qttags") );
        return;
   	}
    QString read;
    read = file.readAll();
    file.close();
    file.remove();
    f.remove();
    QMap<QString, QString> inheritsList;
    QMap<QString, TagList> map;
    foreach(QString s, read.split("\n", QString::SkipEmptyParts) )
    {
        QString classname;
        Tag tag;
        if ( !s.isEmpty() && s.simplified().at(0) == '!' )
            continue;
        s += '\t';
        tag.name = s.section("\t", 0, 0).simplified();
        QString ex_cmd = s.section("/^", -1, -1).section("$/", 0, 0).simplified();
        tag.isStatic = ex_cmd.startsWith("static");
        classname = s.section("class:", -1, -1).section("\t", 0, 0).simplified();
        tag.access =  s.section("access:", -1, -1).section("\t", 0, 0).simplified();
        if ( !QString("public:private:protected").contains( tag.access ) )
            tag.access = "public";
        tag.longName =  ex_cmd;
        tag.kind = s.section("kind:", -1, -1).section("\t", 0, 0).simplified();
        if ( classname.isEmpty() )
            continue;
        tag.parameters = "(" + tag.longName.section("(", 1, 1).section(")", -2, -2) + ")";
        tag.signature = ex_cmd;
        tag.isFunction = true;
        tag.signature = s.section("signature:", -1, -1).section("\t", 0, 0).simplified();
        tag.kind = s.section("kind:", -1, -1).section("\t", 0, 0).simplified();
        tag.returned = ex_cmd;
        if ( tag.returned.startsWith("static ") )
            tag.returned = tag.returned.section("static ", 1);
        if ( tag.returned.startsWith("inline ") )
            tag.returned = tag.returned.section("inline ", 1);
        if ( tag.returned.startsWith("const ") )
            tag.returned = tag.returned.section("const ", 1);
        if ( tag.returned.startsWith("QT3_SUPPORT ") )
            tag.returned = tag.returned.section("QT3_SUPPORT ", 1);
        if ( tag.returned.startsWith("virtual ") )
            tag.returned = tag.returned.section("virtual ", 1);