sqlite3gen.cpp File Reference

#include "sqlite3gen.h"
#include <sys/stat.h>
#include <string.h>
#include <sqlite3.h>
#include "arguments.h"
#include "classlist.h"
#include "conceptdef.h"
#include "config.h"
#include "datetime.h"
#include "dir.h"
#include "docnode.h"
#include "docparser.h"
#include "doxygen.h"
#include "filedef.h"
#include "fileinfo.h"
#include "filename.h"
#include "groupdef.h"
#include "memberdef.h"
#include "membername.h"
#include "message.h"
#include "moduledef.h"
#include "namespacedef.h"
#include "outputlist.h"
#include "pagedef.h"
#include "util.h"
#include "version.h"
#include "xmldocvisitor.h"

Include dependency graph for sqlite3gen.cpp:

Go to the source code of this file.

Classes
struct	SqlStmt
class	TextGeneratorSqlite3Impl
struct	Refid

Macros
#define	DBG_CTX(x)

Functions
static bool	bindTextParameter (SqlStmt &s, const char *name, const DString &value)
static bool	bindIntParameter (SqlStmt &s, const char *name, int value)
static bool	bindIntParameter (SqlStmt &s, const char *name, size_t value)
static int	step (SqlStmt &s, bool getRowId=false, bool select=false)
static int	insertPath (DString name, bool local=true, bool found=true, int type=1)
static void	recordMetadata ()
struct Refid	insertRefid (const DString &refid)
static bool	memberdefExists (struct Refid refid)
static bool	memberdefIncomplete (struct Refid refid, const MemberDef *md)
static bool	compounddefExists (struct Refid refid)
static bool	insertMemberReference (struct Refid src_refid, struct Refid dst_refid, const char *context)
static void	insertMemberReference (const MemberDef *src, const MemberDef *dst, const char *context)
static void	insertMemberFunctionParams (int memberdef_id, const MemberDef *md, const Definition *def)
static void	insertMemberDefineParams (int memberdef_id, const MemberDef *md, const Definition *def)
static void	associateMember (const MemberDef *md, struct Refid member_refid, struct Refid scope_refid)
static void	stripQualifiers (DString &typeStr)
static int	prepareStatement (sqlite3 *db, SqlStmt &s)
static int	prepareStatements (sqlite3 *db)
static void	beginTransaction (sqlite3 *db)
static void	endTransaction (sqlite3 *db)
static void	pragmaTuning (sqlite3 *db)
static int	initializeTables (sqlite3 *db)
static int	initializeViews (sqlite3 *db)
static void	writeInnerClasses (const ClassLinkedRefMap &cl, struct Refid outer_refid)
static void	writeInnerConcepts (const ConceptLinkedRefMap &cl, struct Refid outer_refid)
static void	writeInnerModules (const ModuleLinkedRefMap &ml, struct Refid outer_refid)
static void	writeInnerPages (const PageLinkedRefMap &pl, struct Refid outer_refid)
static void	writeInnerGroups (const GroupList &gl, struct Refid outer_refid)
static void	writeInnerFiles (const FileList &fl, struct Refid outer_refid)
static void	writeInnerDirs (const DirList &dl, struct Refid outer_refid)
static void	writeInnerNamespaces (const NamespaceLinkedRefMap &nl, struct Refid outer_refid)
static void	writeTemplateArgumentList (const ArgumentList &al, const Definition *scope, const FileDef *fileScope)
static void	writeMemberTemplateLists (const MemberDef *md)
static void	writeTemplateList (const ClassDef *cd)
static void	writeTemplateList (const ConceptDef *cd)
DString	getSQLDocBlock (const Definition *scope, const Definition *def, const DString &doc, const DString &fileName, int lineNr)
static void	getSQLDesc (SqlStmt &s, const char *col, const DString &value, const Definition *def)
static void	getSQLDescCompound (SqlStmt &s, const char *col, const DString &value, const Definition *def)
static void	generateSqlite3ForMember (const MemberDef *md, struct Refid scope_refid, const Definition *def)
static void	generateSqlite3Section (const Definition *d, const MemberList *ml, struct Refid scope_refid, const char *, const DString &=DString(), const DString &=DString())
static void	associateAllClassMembers (const ClassDef *cd, struct Refid scope_refid)
static void	generateSqlite3ForClass (const ClassDef *cd)
static void	generateSqlite3ForConcept (const ConceptDef *cd)
static void	generateSqlite3ForModule (const ModuleDef *mod)
static void	generateSqlite3ForNamespace (const NamespaceDef *nd)
static void	generateSqlite3ForFile (const FileDef *fd)
static void	generateSqlite3ForGroup (const GroupDef *gd)
static void	generateSqlite3ForDir (const DirDef *dd)
static void	generateSqlite3ForPage (const PageDef *pd, bool isExample)
static sqlite3 *	openDbConnection ()
void	generateSqlite3 ()

Variables
const char *	table_schema [][2]
const char *	view_schema [][2]
SqlStmt	meta_insert
SqlStmt	incl_insert
SqlStmt	incl_select
SqlStmt	contains_insert
SqlStmt	path_select
SqlStmt	path_insert
SqlStmt	refid_select
SqlStmt	refid_insert
SqlStmt	xrefs_insert
SqlStmt	reimplements_insert
SqlStmt	memberdef_exists
SqlStmt	memberdef_incomplete
SqlStmt	memberdef_insert
SqlStmt	memberdef_update_decl
SqlStmt	memberdef_update_def
SqlStmt	member_insert
SqlStmt	compounddef_insert
SqlStmt	compounddef_exists
SqlStmt	compoundref_insert
SqlStmt	param_select
SqlStmt	param_insert
SqlStmt	memberdef_param_insert

Macro Definition Documentation

DBG_CTX

#define DBG_CTX

(

x

)

Value:

do { } while(0)

Definition at line 60 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForClass(), generateSqlite3ForFile(), generateSqlite3ForMember(), insertMemberDefineParams(), insertMemberFunctionParams(), step(), and TextGeneratorSqlite3Impl::writeBreak().

Function Documentation

associateAllClassMembers()

void associateAllClassMembers ( const ClassDef * cd, struct Refid scope_refid )

static

Definition at line 1888 of file sqlite3gen.cpp.

{
  for (auto &mni : cd->memberNameInfoLinkedMap())
  {
    for (auto &mi : *mni)
    {
      const MemberDef *md = mi->memberDef();
      DString qrefid = md->getOutputFileBase() + "_1" + md->anchor();
      associateMember(md, insertRefid(qrefid), scope_refid);
    }
  }
}

References Definition::anchor(), associateMember(), Definition::getOutputFileBase(), insertRefid(), and ClassDef::memberNameInfoLinkedMap().

Referenced by generateSqlite3ForClass().

associateMember()

void associateMember ( const MemberDef * md, struct Refid member_refid, struct Refid scope_refid )

static

Definition at line 1124 of file sqlite3gen.cpp.

{
  // TODO: skip EnumValue only to guard against recording refids and member records
  // for enumvalues until we can support documenting them as entities.
  if (md->memberType()==MemberType::EnumValue) return;
  if (!md->isAnonymous()) // skip anonymous members
  {
    bindIntParameter(member_insert, ":scope_rowid", scope_refid.rowid);
    bindIntParameter(member_insert, ":memberdef_rowid", member_refid.rowid);
 
    bindIntParameter(member_insert, ":prot", static_cast<int>(md->protection()));
    bindIntParameter(member_insert, ":virt", static_cast<int>(md->virtualness()));
    step(member_insert);
  }
}

References bindIntParameter(), Definition::isAnonymous(), member_insert, MemberDef::memberType(), MemberDef::protection(), Refid::rowid, step(), and MemberDef::virtualness().

Referenced by associateAllClassMembers(), and generateSqlite3ForMember().

beginTransaction()

void beginTransaction ( sqlite3 * db )

static

Definition at line 1197 of file sqlite3gen.cpp.

{
  char * sErrMsg = nullptr;
  sqlite3_exec(db, "BEGIN TRANSACTION", nullptr, nullptr, &sErrMsg);
}

Referenced by generateSqlite3().

bindIntParameter() [1/2]

bool bindIntParameter ( SqlStmt & s, const char * name, int value )

static

Definition at line 873 of file sqlite3gen.cpp.

{
  int idx = sqlite3_bind_parameter_index(s.stmt, name);
  if (idx==0) {
    err("sqlite3_bind_parameter_index({})[{}] failed to find column: {}\n", name, s.query, sqlite3_errmsg(s.db));
    return false;
  }
  int rv = sqlite3_bind_int(s.stmt, idx, value);
  if (rv!=SQLITE_OK) {
    err("sqlite3_bind_int({})[{}] failed: {}\n", name, s.query, sqlite3_errmsg(s.db));
    return false;
  }
  return true;
}

References SqlStmt::db, err, SqlStmt::query, and SqlStmt::stmt.

Referenced by associateMember(), bindIntParameter(), compounddefExists(), generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForMember(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateSqlite3ForPage(), insertMemberDefineParams(), insertMemberFunctionParams(), insertMemberReference(), insertPath(), memberdefExists(), memberdefIncomplete(), writeInnerClasses(), writeInnerConcepts(), writeInnerDirs(), writeInnerFiles(), writeInnerGroups(), writeInnerModules(), writeInnerNamespaces(), and writeInnerPages().

bindIntParameter() [2/2]

bool bindIntParameter ( SqlStmt & s, const char * name, size_t value )

static

Definition at line 888 of file sqlite3gen.cpp.

{
  return bindIntParameter(s,name,static_cast<int>(value));
}

References bindIntParameter().

bindTextParameter()

bool bindTextParameter ( SqlStmt & s, const char * name, const DString & value )

static

Definition at line 858 of file sqlite3gen.cpp.

{
  int idx = sqlite3_bind_parameter_index(s.stmt, name);
  if (idx==0) {
    err("sqlite3_bind_parameter_index({})[{}] failed: {}\n", name, s.query, sqlite3_errmsg(s.db));
    return false;
  }
  int rv = sqlite3_bind_text(s.stmt, idx, value.data(), -1, SQLITE_TRANSIENT);
  if (rv!=SQLITE_OK) {
    err("sqlite3_bind_text({})[{}] failed: {}\n", name, s.query, sqlite3_errmsg(s.db));
    return false;
  }
  return true;
}

References DString::data(), SqlStmt::db, err, SqlStmt::query, and SqlStmt::stmt.

Referenced by generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForMember(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateSqlite3ForPage(), getSQLDesc(), getSQLDescCompound(), insertMemberDefineParams(), insertMemberFunctionParams(), insertMemberReference(), insertPath(), insertRefid(), recordMetadata(), and writeTemplateArgumentList().

compounddefExists()

bool compounddefExists ( struct Refid refid )

static

Definition at line 984 of file sqlite3gen.cpp.

{
  bindIntParameter(compounddef_exists,":rowid",refid.rowid);
  int test = step(compounddef_exists,true,true);
  return test ? true : false;
}

References bindIntParameter(), compounddef_exists, Refid::refid, and step().

Referenced by generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), and generateSqlite3ForPage().

endTransaction()

void endTransaction ( sqlite3 * db )

static

Definition at line 1203 of file sqlite3gen.cpp.

{
  char * sErrMsg = nullptr;
  sqlite3_exec(db, "END TRANSACTION", nullptr, nullptr, &sErrMsg);
}

Referenced by generateSqlite3().

generateSqlite3()

void generateSqlite3

(

)

Definition at line 2577 of file sqlite3gen.cpp.

{
  // + classes
  // + namespaces
  // + files
  // + groups
  // + related pages
  // + examples
  // + main page
  sqlite3 *db = openDbConnection();
  if (db==nullptr)
  {
    return;
  }
 
# ifdef SQLITE3_DEBUG
  // debug: show all executed statements
  sqlite3_trace(db, &sqlLog, nullptr);
# endif
 
  beginTransaction(db);
  pragmaTuning(db);
 
  if (-1==initializeTables(db))
    return;
 
  if ( -1 == prepareStatements(db) )
  {
    err("sqlite generator: prepareStatements failed!\n");
    return;
  }
 
  recordMetadata();
 
  // + classes
  for (const auto &cd : *Doxygen::classLinkedMap)
  {
    msg("Generating Sqlite3 output for class {}\n",cd->name());
    generateSqlite3ForClass(cd.get());
  }
 
  // + concepts
  for (const auto &cd : *Doxygen::conceptLinkedMap)
  {
    msg("Generating Sqlite3 output for concept {}\n",cd->name());
    generateSqlite3ForConcept(cd.get());
  }
 
  // + modules
  for (const auto &mod : ModuleManager::instance().modules())
  {
    msg("Generating Sqlite3 output for module {}\n",mod->name());
    generateSqlite3ForModule(mod.get());
  }
 
  // + namespaces
  for (const auto &nd : *Doxygen::namespaceLinkedMap)
  {
    msg("Generating Sqlite3 output for namespace {}\n",nd->name());
    generateSqlite3ForNamespace(nd.get());
  }
 
  // + files
  for (const auto &fn : *Doxygen::inputNameLinkedMap)
  {
    for (const auto &fd : *fn)
    {
      msg("Generating Sqlite3 output for file {}\n",fd->name());
      generateSqlite3ForFile(fd.get());
    }
  }
 
  // + groups
  for (const auto &gd : *Doxygen::groupLinkedMap)
  {
    msg("Generating Sqlite3 output for group {}\n",gd->name());
    generateSqlite3ForGroup(gd.get());
  }
 
  // + page
  for (const auto &pd : *Doxygen::pageLinkedMap)
  {
    msg("Generating Sqlite3 output for page {}\n",pd->name());
    generateSqlite3ForPage(pd.get(),false);
  }
 
  // + dirs
  for (const auto &dd : *Doxygen::dirLinkedMap)
  {
    msg("Generating Sqlite3 output for dir {}\n",dd->name());
    generateSqlite3ForDir(dd.get());
  }
 
  // + examples
  for (const auto &pd : *Doxygen::exampleLinkedMap)
  {
    msg("Generating Sqlite3 output for example {}\n",pd->name());
    generateSqlite3ForPage(pd.get(),true);
  }
 
  // + main page
  if (Doxygen::mainPage)
  {
    msg("Generating Sqlite3 output for the main page\n");
    generateSqlite3ForPage(Doxygen::mainPage.get(),false);
  }
 
  // TODO: copied from initializeSchema; not certain if we should say/do more
  // if there's a failure here?
  if (-1==initializeViews(db))
    return;
 
  endTransaction(db);
}

References beginTransaction(), Doxygen::classLinkedMap, Doxygen::conceptLinkedMap, Doxygen::dirLinkedMap, endTransaction(), err, Doxygen::exampleLinkedMap, generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateSqlite3ForPage(), Doxygen::groupLinkedMap, initializeTables(), initializeViews(), Doxygen::inputNameLinkedMap, ModuleManager::instance(), Doxygen::mainPage, msg, Doxygen::namespaceLinkedMap, openDbConnection(), Doxygen::pageLinkedMap, pragmaTuning(), prepareStatements(), and recordMetadata().

Referenced by generateOutput().

generateSqlite3ForClass()

void generateSqlite3ForClass ( const ClassDef * cd )

static

Definition at line 1904 of file sqlite3gen.cpp.

{
  // NOTE: Skeptical about XML's version of these
  // 'x' marks missing items XML claims to include
 
  // + brief description
  // + detailed description
  // + template argument list(s)
  // + include file
  // + member groups
  // x inheritance DOT diagram
  // + list of direct super classes
  // + list of direct sub classes
  // + list of inner classes
  // x collaboration DOT diagram
  // + list of all members
  // x user defined member sections
  // x standard member sections
  // x detailed member documentation
  // - examples using the class
 
  if (cd->isReference())        return; // skip external references.
  if (cd->isHidden())           return; // skip hidden classes.
  if (cd->isAnonymous())        return; // skip anonymous compounds.
  if (cd->isImplicitTemplateInstance())  return; // skip generated template instances.
 
  struct Refid refid = insertRefid(cd->getOutputFileBase());
 
  // can omit a class that already has a refid
  if(!refid.created && compounddefExists(refid)){return;}
 
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
 
  bindTextParameter(compounddef_insert,":name",cd->name());
  bindTextParameter(compounddef_insert,":title",cd->title());
  bindTextParameter(compounddef_insert,":kind",cd->compoundTypeString());
  bindIntParameter(compounddef_insert,":prot",static_cast<int>(cd->protection()));
 
  int file_id = insertPath(cd->getDefFileName());
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",cd->getDefLine());
  bindIntParameter(compounddef_insert,":column",cd->getDefColumn());
 
  // + include file
  /*
  TODO: I wonder if this can actually be cut (just here)
 
  We were adding this "include" to the "includes" table alongside
  other includes (from a FileDef). However, FileDef and ClassDef are using
  "includes" nodes in very a different way:
  - With FileDef, it means the file includes another.
  - With ClassDef, it means you should include this file to use this class.
 
  Because of this difference, I added a column to compounddef, header_id, and
  linked it back to the appropriate file. We could just add a nullable text
  column that would hold a string equivalent to what the HTML docs include,
  but the logic for generating it is embedded in
  ClassDef::writeIncludeFiles(OutputList &ol).
 
  That said, at least on the handful of test sets I have, header_id == file_id,
  suggesting it could be cut and clients might be able to reconstruct it from
  other values if there's a solid heuristic for *when a class will
  have a header file*.
  */
  const IncludeInfo *ii=cd->includeInfo();
  if (ii)
  {
    DString nm = ii->includeName;
    if (nm.empty() && ii->fileDef) nm = ii->fileDef->docName();
    if (!nm.empty())
    {
      int header_id=-1;
      if (ii->fileDef)
      {
        insertPath(ii->fileDef->absFilePath(),!ii->fileDef->isReference());
      }
      DBG_CTX(("-----> ClassDef includeInfo for %s\n", qPrint(nm)));
      DBG_CTX(("       local    : %d\n", ii->local));
      DBG_CTX(("       imported : %d\n", ii->imported));
      if (ii->fileDef)
      {
          DBG_CTX(("header: %s\n", qPrint(ii->fileDef->absFilePath())));
      }
      DBG_CTX(("       file_id  : %d\n", file_id));
      DBG_CTX(("       header_id: %d\n", header_id));
 
      if(header_id!=-1)
      {
        bindIntParameter(compounddef_insert,":header_id",header_id);
      }
    }
  }
 
  getSQLDescCompound(compounddef_insert,":briefdescription",cd->briefDescription(),cd);
  getSQLDescCompound(compounddef_insert,":detaileddescription",cd->documentation(),cd);
 
  step(compounddef_insert);
 
  // + list of direct super classes
  for (const auto &bcd : cd->baseClasses())
  {
    struct Refid base_refid = insertRefid(bcd.classDef->getOutputFileBase());
    struct Refid derived_refid = insertRefid(cd->getOutputFileBase());
    bindIntParameter(compoundref_insert,":base_rowid", base_refid.rowid);
    bindIntParameter(compoundref_insert,":derived_rowid", derived_refid.rowid);
    bindIntParameter(compoundref_insert,":prot",static_cast<int>(bcd.prot));
    bindIntParameter(compoundref_insert,":virt",static_cast<int>(bcd.virt));
    step(compoundref_insert);
  }
 
  // + list of direct sub classes
  for (const auto &bcd : cd->subClasses())
  {
    struct Refid derived_refid = insertRefid(bcd.classDef->getOutputFileBase());
    struct Refid base_refid = insertRefid(cd->getOutputFileBase());
    bindIntParameter(compoundref_insert,":base_rowid", base_refid.rowid);
    bindIntParameter(compoundref_insert,":derived_rowid", derived_refid.rowid);
    bindIntParameter(compoundref_insert,":prot",static_cast<int>(bcd.prot));
    bindIntParameter(compoundref_insert,":virt",static_cast<int>(bcd.virt));
    step(compoundref_insert);
  }
 
  // + list of inner classes
  writeInnerClasses(cd->getClasses(),refid);
 
  // + template argument list(s)
  writeTemplateList(cd);
 
  // + member groups
  for (const auto &mg : cd->getMemberGroups())
  {
    generateSqlite3Section(cd,&mg->members(),refid,"user-defined",mg->header(),
        mg->documentation());
  }
 
  // this is just a list of *local* members
  for (const auto &ml : cd->getMemberLists())
  {
    if (!ml->listType().isDetailed())
    {
      generateSqlite3Section(cd,ml.get(),refid,"user-defined");
    }
  }
 
  // + list of all members
  associateAllClassMembers(cd, refid);
}

References FileDef::absFilePath(), associateAllClassMembers(), ClassDef::baseClasses(), bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), compoundref_insert, ClassDef::compoundTypeString(), DBG_CTX, FileDef::docName(), Definition::documentation(), DString::empty(), IncludeInfo::fileDef, generateSqlite3Section(), ClassDef::getClasses(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), ClassDef::getMemberGroups(), ClassDef::getMemberLists(), Definition::getOutputFileBase(), getSQLDescCompound(), ClassDef::includeInfo(), IncludeInfo::includeName, insertPath(), insertRefid(), Definition::isAnonymous(), MemberListType::isDetailed(), Definition::isHidden(), ClassDef::isImplicitTemplateInstance(), Definition::isReference(), MemberList::listType(), Definition::name(), ClassDef::protection(), qPrint(), Refid::refid, Refid::rowid, step(), ClassDef::subClasses(), ClassDef::title(), writeInnerClasses(), and writeTemplateList().

Referenced by generateSqlite3().

generateSqlite3ForConcept()

void generateSqlite3ForConcept ( const ConceptDef * cd )

static

Definition at line 2052 of file sqlite3gen.cpp.

{
  if (cd->isReference() || cd->isHidden()) return; // skip external references
 
  struct Refid refid = insertRefid(cd->getOutputFileBase());
  if(!refid.created && compounddefExists(refid)){return;}
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
  bindTextParameter(compounddef_insert,":name",cd->name());
  bindTextParameter(compounddef_insert,":kind","concept");
 
  int file_id = insertPath(cd->getDefFileName());
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",cd->getDefLine());
  bindIntParameter(compounddef_insert,":column",cd->getDefColumn());
 
  getSQLDescCompound(compounddef_insert,":briefdescription",cd->briefDescription(),cd);
  getSQLDescCompound(compounddef_insert,":detaileddescription",cd->documentation(),cd);
 
  step(compounddef_insert);
 
  // + template argument list(s)
  writeTemplateList(cd);
}

References bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), Definition::documentation(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), Definition::getOutputFileBase(), getSQLDescCompound(), insertPath(), insertRefid(), Definition::isHidden(), Definition::isReference(), Definition::name(), Refid::refid, step(), and writeTemplateList().

Referenced by generateSqlite3().

generateSqlite3ForDir()

void generateSqlite3ForDir ( const DirDef * dd )

static

Definition at line 2413 of file sqlite3gen.cpp.

{
  // + dirs
  // + files
  // + briefdescription
  // + detaileddescription
  // + location (below uses file_id, line, column; XML just uses file)
  if (dd->isReference()) return; // skip external references
 
  struct Refid refid = insertRefid(dd->getOutputFileBase());
  if(!refid.created && compounddefExists(refid)){return;}
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
 
  bindTextParameter(compounddef_insert,":name",dd->displayName());
  bindTextParameter(compounddef_insert,":kind","dir");
 
  int file_id = insertPath(dd->getDefFileName(),true,true,2);
  bindIntParameter(compounddef_insert,":file_id",file_id);
 
  /*
  line and column are weird here, but:
  - dir goes into compounddef with all of the others
  - the semantics would be fine if we set them to NULL here
  - but defining line and column as NOT NULL is an important promise
    for other compounds, so I don't want to loosen it
 
  For reference, the queries return 1.
  0 or -1 make more sense, but I see that as a change for DirDef.
  */
  bindIntParameter(compounddef_insert,":line",dd->getDefLine());
  bindIntParameter(compounddef_insert,":column",dd->getDefColumn());
 
  getSQLDesc(compounddef_insert,":briefdescription",dd->briefDescription(),dd);
  getSQLDesc(compounddef_insert,":detaileddescription",dd->documentation(),dd);
 
  step(compounddef_insert);
 
  // + files
  writeInnerDirs(dd->subDirs(),refid);
 
  // + files
  writeInnerFiles(dd->getFiles(),refid);
}

References bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), Definition::displayName(), Definition::documentation(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), DirDef::getFiles(), Definition::getOutputFileBase(), getSQLDesc(), insertPath(), insertRefid(), Definition::isReference(), Refid::refid, step(), DirDef::subDirs(), writeInnerDirs(), and writeInnerFiles().

Referenced by generateSqlite3().

generateSqlite3ForFile()

void generateSqlite3ForFile ( const FileDef * fd )

static

Definition at line 2189 of file sqlite3gen.cpp.

{
  // + includes files
  // + includedby files
  // x include graph
  // x included by graph
  // + contained class definitions
  // + contained namespace definitions
  // + member groups
  // + normal members
  // + brief desc
  // + detailed desc
  // x source code
  // + location (file_id, line, column)
  // - number of lines
 
  if (fd->isReference()) return; // skip external references
 
  struct Refid refid = insertRefid(fd->getOutputFileBase());
  if(!refid.created && compounddefExists(refid)){return;}
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
 
  bindTextParameter(compounddef_insert,":name",fd->name());
  bindTextParameter(compounddef_insert,":title",fd->title());
  bindTextParameter(compounddef_insert,":kind","file");
 
  int file_id = insertPath(fd->getDefFileName());
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",fd->getDefLine());
  bindIntParameter(compounddef_insert,":column",fd->getDefColumn());
 
  getSQLDesc(compounddef_insert,":briefdescription",fd->briefDescription(),fd);
  getSQLDesc(compounddef_insert,":detaileddescription",fd->documentation(),fd);
 
  step(compounddef_insert);
 
  // + includes files
  for (const auto &ii : fd->includeFileList())
  {
    int src_id=insertPath(fd->absFilePath(),!fd->isReference());
    int dst_id=0;
    DString dst_path;
    bool isLocal = (ii.kind & IncludeKind_LocalMask)!=0;
 
    if(ii.fileDef) // found file
    {
      if(ii.fileDef->isReference())
      {
        // strip tagfile from path
        DString tagfile = ii.fileDef->getReference();
        dst_path = ii.fileDef->absFilePath();
        dst_path.stripPrefix(tagfile+":");
      }
      else
      {
        dst_path = ii.fileDef->absFilePath();
      }
      dst_id = insertPath(dst_path,isLocal);
    }
    else // can't find file
    {
      dst_id = insertPath(ii.includeName,isLocal,false);
    }
 
    DBG_CTX(("-----> FileDef includeInfo for %s\n", qPrint(ii.includeName)));
    DBG_CTX(("       local:    %d\n", isLocal));
    DBG_CTX(("       imported: %d\n", (ii.kind & IncludeKind_ImportMask)!=0));
    if(ii.fileDef)
    {
      DBG_CTX(("include: %s\n", qPrint(ii.fileDef->absFilePath())));
    }
    DBG_CTX(("       src_id  : %d\n", src_id));
    DBG_CTX(("       dst_id: %d\n", dst_id));
 
    bindIntParameter(incl_select,":local",isLocal);
    bindIntParameter(incl_select,":src_id",src_id);
    bindIntParameter(incl_select,":dst_id",dst_id);
    if (step(incl_select,true,true)==0) {
      bindIntParameter(incl_insert,":local",isLocal);
      bindIntParameter(incl_insert,":src_id",src_id);
      bindIntParameter(incl_insert,":dst_id",dst_id);
      step(incl_insert);
    }
  }
 
  // + includedby files
  for (const auto &ii : fd->includedByFileList())
  {
    int dst_id=insertPath(fd->absFilePath(),!fd->isReference());
    int src_id=0;
    DString src_path;
    bool isLocal = (ii.kind & IncludeKind_LocalMask)!=0;
 
    if(ii.fileDef) // found file
    {
      if(ii.fileDef->isReference())
      {
        // strip tagfile from path
        DString tagfile = ii.fileDef->getReference();
        src_path = ii.fileDef->absFilePath();
        src_path.stripPrefix(tagfile+":");
      }
      else
      {
        src_path = ii.fileDef->absFilePath();
      }
      src_id = insertPath(src_path,isLocal);
    }
    else // can't find file
    {
      src_id = insertPath(ii.includeName,isLocal,false);
    }
 
    bindIntParameter(incl_select,":local",isLocal);
    bindIntParameter(incl_select,":src_id",src_id);
    bindIntParameter(incl_select,":dst_id",dst_id);
    if (step(incl_select,true,true)==0) {
      bindIntParameter(incl_insert,":local",isLocal);
      bindIntParameter(incl_insert,":src_id",src_id);
      bindIntParameter(incl_insert,":dst_id",dst_id);
      step(incl_insert);
    }
  }
 
  // + contained class definitions
  writeInnerClasses(fd->getClasses(),refid);
 
  // + contained concept definitions
  writeInnerConcepts(fd->getConcepts(),refid);
 
  // + contained namespace definitions
  writeInnerNamespaces(fd->getNamespaces(),refid);
 
  // + member groups
  for (const auto &mg : fd->getMemberGroups())
  {
    generateSqlite3Section(fd,&mg->members(),refid,"user-defined",mg->header(),
          mg->documentation());
  }
 
  // + normal members
  for (const auto &ml : fd->getMemberLists())
  {
    if (ml->listType().isDeclaration())
    {
      generateSqlite3Section(fd,ml.get(),refid,"user-defined");
    }
  }
}

References FileDef::absFilePath(), bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), DBG_CTX, Definition::documentation(), generateSqlite3Section(), FileDef::getClasses(), FileDef::getConcepts(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), FileDef::getMemberGroups(), FileDef::getMemberLists(), FileDef::getNamespaces(), Definition::getOutputFileBase(), getSQLDesc(), incl_insert, incl_select, FileDef::includedByFileList(), FileDef::includeFileList(), IncludeKind_ImportMask, IncludeKind_LocalMask, insertPath(), insertRefid(), MemberListType::isDeclaration(), Definition::isReference(), MemberList::listType(), Definition::name(), qPrint(), Refid::refid, step(), DString::stripPrefix(), FileDef::title(), writeInnerClasses(), writeInnerConcepts(), and writeInnerNamespaces().

Referenced by generateSqlite3().

generateSqlite3ForGroup()

void generateSqlite3ForGroup ( const GroupDef * gd )

static

Definition at line 2340 of file sqlite3gen.cpp.

{
  // + members
  // + member groups
  // + files
  // + classes
  // + namespaces
  // - packages
  // + pages
  // + child groups
  // - examples
  // + brief description
  // + detailed description
 
  if (gd->isReference()) return; // skip external references.
 
  struct Refid refid = insertRefid(gd->getOutputFileBase());
  if(!refid.created && compounddefExists(refid)){return;}
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
 
  bindTextParameter(compounddef_insert,":name",gd->name());
  bindTextParameter(compounddef_insert,":title",gd->groupTitle());
  bindTextParameter(compounddef_insert,":kind","group");
 
  int file_id = insertPath(gd->getDefFileName());
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",gd->getDefLine());
  bindIntParameter(compounddef_insert,":column",gd->getDefColumn());
 
  getSQLDesc(compounddef_insert,":briefdescription",gd->briefDescription(),gd);
  getSQLDesc(compounddef_insert,":detaileddescription",gd->documentation(),gd);
 
  step(compounddef_insert);
 
  // + files
  writeInnerFiles(gd->getFiles(),refid);
 
  // + classes
  writeInnerClasses(gd->getClasses(),refid);
 
  // + concepts
  writeInnerConcepts(gd->getConcepts(),refid);
 
  // + modules
  writeInnerModules(gd->getModules(),refid);
 
  // + namespaces
  writeInnerNamespaces(gd->getNamespaces(),refid);
 
  // + pages
  writeInnerPages(gd->getPages(),refid);
 
  // + groups
  writeInnerGroups(gd->getSubGroups(),refid);
 
  // + member groups
  for (const auto &mg : gd->getMemberGroups())
  {
    generateSqlite3Section(gd,&mg->members(),refid,"user-defined",mg->header(),
        mg->documentation());
  }
 
  // + members
  for (const auto &ml : gd->getMemberLists())
  {
    if (ml->listType().isDeclaration())
    {
      generateSqlite3Section(gd,ml.get(),refid,"user-defined");
    }
  }
}

References bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), Definition::documentation(), generateSqlite3Section(), GroupDef::getClasses(), GroupDef::getConcepts(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), GroupDef::getFiles(), GroupDef::getMemberGroups(), GroupDef::getMemberLists(), GroupDef::getModules(), GroupDef::getNamespaces(), Definition::getOutputFileBase(), GroupDef::getPages(), getSQLDesc(), GroupDef::getSubGroups(), GroupDef::groupTitle(), insertPath(), insertRefid(), MemberListType::isDeclaration(), Definition::isReference(), MemberList::listType(), Definition::name(), Refid::refid, step(), writeInnerClasses(), writeInnerConcepts(), writeInnerFiles(), writeInnerGroups(), writeInnerModules(), writeInnerNamespaces(), and writeInnerPages().

Referenced by generateSqlite3().

generateSqlite3ForMember()

void generateSqlite3ForMember ( const MemberDef * md, struct Refid scope_refid, const Definition * def )

static

Definition at line 1551 of file sqlite3gen.cpp.

{
  // + declaration/definition arg lists
  // + reimplements
  // + reimplementedBy
  // - exceptions
  // + const/volatile specifiers
  // - examples
  // + source definition
  // + source references
  // + source referenced by
  // - body code
  // + template arguments
  //     (templateArguments(), definitionTemplateParameterLists())
  // - call graph
 
  // enum values are written as part of the enum
  if (md->memberType()==MemberType::EnumValue) return;
  if (md->isHidden()) return;
 
  DString memType;
 
  // memberdef
  DString qrefid = md->getOutputFileBase() + "_1" + md->anchor();
  struct Refid refid = insertRefid(qrefid);
 
  associateMember(md, refid, scope_refid);
 
  // compacting duplicate defs
  if(!refid.created && memberdefExists(refid) && memberdefIncomplete(refid, md))
  {
    /*
    For performance, ideal to skip a member we've already added.
    Unfortunately, we can have two memberdefs with the same refid documenting
    the declaration and definition. memberdefIncomplete() uses the 'inline'
    value to figure this out. Once we get to this point, we should *only* be
    seeing the *other* type of def/decl, so we'll set inline to a new value (2),
    indicating that this entry covers both inline types.
    */
    struct SqlStmt memberdef_update;
 
    // definitions have bodyfile/start/end
    if (md->getStartBodyLine()!=-1)
    {
      memberdef_update = memberdef_update_def;
      int bodyfile_id = insertPath(md->getBodyDef()->absFilePath(),!md->getBodyDef()->isReference());
      if (bodyfile_id == -1)
      {
          sqlite3_clear_bindings(memberdef_update.stmt);
      }
      else
      {
          bindIntParameter(memberdef_update,":bodyfile_id",bodyfile_id);
          bindIntParameter(memberdef_update,":bodystart",md->getStartBodyLine());
          bindIntParameter(memberdef_update,":bodyend",md->getEndBodyLine());
      }
    }
    // declarations don't
    else
    {
      memberdef_update = memberdef_update_decl;
      if (md->getDefLine() != -1)
      {
        int file_id = insertPath(md->getDefFileName(),!md->isReference());
        if (file_id!=-1)
        {
          bindIntParameter(memberdef_update,":file_id",file_id);
          bindIntParameter(memberdef_update,":line",md->getDefLine());
          bindIntParameter(memberdef_update,":column",md->getDefColumn());
        }
      }
    }
 
    bindIntParameter(memberdef_update, ":rowid", refid.rowid);
    // value 2 indicates we've seen "both" inline types.
    bindIntParameter(memberdef_update,":inline", 2);
 
    /* in case both are used, append/prepend descriptions */
    getSQLDesc(memberdef_update,":briefdescription",md->briefDescription(),md);
    getSQLDesc(memberdef_update,":detaileddescription",md->documentation(),md);
    getSQLDesc(memberdef_update,":inbodydescription",md->inbodyDocumentation(),md);
 
    step(memberdef_update,true);
 
    // don't think we need to repeat params; should have from first encounter
 
    // + source references
    // The cross-references in initializers only work when both the src and dst
    // are defined.
    auto refList = md->getReferencesMembers();
    for (const auto &rmd : refList)
    {
      insertMemberReference(md,rmd, "inline");
    }
    // + source referenced by
    auto refByList = md->getReferencedByMembers();
    for (const auto &rmd : refByList)
    {
      insertMemberReference(rmd,md, "inline");
    }
    return;
  }
 
  bindIntParameter(memberdef_insert,":rowid", refid.rowid);
  bindTextParameter(memberdef_insert,":kind",md->memberTypeName());
  bindIntParameter(memberdef_insert,":prot",static_cast<int>(md->protection()));
 
  bindIntParameter(memberdef_insert,":static",md->isStatic());
  bindIntParameter(memberdef_insert,":extern",md->isExternal());
 
  bool isFunc=to_isFunction(md->memberType());
 
  if (isFunc)
  {
    const ArgumentList &al = md->argumentList();
    bindIntParameter(memberdef_insert,":const",al.constSpecifier());
    bindIntParameter(memberdef_insert,":volatile",al.volatileSpecifier());
    bindIntParameter(memberdef_insert,":explicit",md->isExplicit());
    bindIntParameter(memberdef_insert,":inline",md->isInline());
    bindIntParameter(memberdef_insert,":final",md->isFinal());
    bindIntParameter(memberdef_insert,":sealed",md->isSealed());
    bindIntParameter(memberdef_insert,":new",md->isNew());
    bindIntParameter(memberdef_insert,":optional",md->isOptional());
    bindIntParameter(memberdef_insert,":required",md->isRequired());
 
    bindIntParameter(memberdef_insert,":virt",static_cast<int>(md->virtualness()));
  }
 
  if (md->memberType() == MemberType::Variable)
  {
    bindIntParameter(memberdef_insert,":mutable",md->isMutable());
    bindIntParameter(memberdef_insert,":thread_local",md->isThreadLocal());
    bindIntParameter(memberdef_insert,":initonly",md->isInitonly());
    bindIntParameter(memberdef_insert,":attribute",md->isAttribute());
    bindIntParameter(memberdef_insert,":property",md->isProperty());
    bindIntParameter(memberdef_insert,":readonly",md->isReadonly());
    bindIntParameter(memberdef_insert,":bound",md->isBound());
    bindIntParameter(memberdef_insert,":removable",md->isRemovable());
    bindIntParameter(memberdef_insert,":constrained",md->isConstrained());
    bindIntParameter(memberdef_insert,":transient",md->isTransient());
    bindIntParameter(memberdef_insert,":maybevoid",md->isMaybeVoid());
    bindIntParameter(memberdef_insert,":maybedefault",md->isMaybeDefault());
    bindIntParameter(memberdef_insert,":maybeambiguous",md->isMaybeAmbiguous());
    if (!md->bitfieldString().empty())
    {
      DString bitfield = md->bitfieldString();
      if (bitfield.at(0)==':') bitfield=bitfield.mid(1);
      bindTextParameter(memberdef_insert,":bitfield",bitfield.stripWhiteSpace());
    }
  }
  else if (md->memberType() == MemberType::Property)
  {
    bindIntParameter(memberdef_insert,":readable",md->isReadable());
    bindIntParameter(memberdef_insert,":writable",md->isWritable());
    bindIntParameter(memberdef_insert,":gettable",md->isGettable());
    bindIntParameter(memberdef_insert,":privategettable",md->isPrivateGettable());
    bindIntParameter(memberdef_insert,":protectedgettable",md->isProtectedGettable());
    bindIntParameter(memberdef_insert,":settable",md->isSettable());
    bindIntParameter(memberdef_insert,":privatesettable",md->isPrivateSettable());
    bindIntParameter(memberdef_insert,":protectedsettable",md->isProtectedSettable());
 
    if (md->isAssign() || md->isCopy() || md->isRetain()
     || md->isStrong() || md->isWeak())
    {
      int accessor=0;
      if (md->isAssign())      accessor = 1;
      else if (md->isCopy())   accessor = 2;
      else if (md->isRetain()) accessor = 3;
      else if (md->isStrong()) accessor = 4;
      else if (md->isWeak())   accessor = 5;
 
      bindIntParameter(memberdef_insert,":accessor",accessor);
    }
    bindTextParameter(memberdef_insert,":read",md->getReadAccessor());
    bindTextParameter(memberdef_insert,":write",md->getWriteAccessor());
  }
  else if (md->memberType() == MemberType::Event)
  {
    bindIntParameter(memberdef_insert,":addable",md->isAddable());
    bindIntParameter(memberdef_insert,":removable",md->isRemovable());
    bindIntParameter(memberdef_insert,":raisable",md->isRaisable());
  }
 
  const MemberDef *rmd = md->reimplements();
  if (rmd)
  {
    DString qreimplemented_refid = rmd->getOutputFileBase() + "_1" + rmd->anchor();
 
    struct Refid reimplemented_refid = insertRefid(qreimplemented_refid);
 
    bindIntParameter(reimplements_insert,":memberdef_rowid", refid.rowid);
    bindIntParameter(reimplements_insert,":reimplemented_rowid", reimplemented_refid.rowid);
    step(reimplements_insert,true);
  }
 
  LinkifyTextOptions options;
  options.setScope(def).setFileScope(md->getBodyDef()).setSelf(md);
 
  // + declaration/definition arg lists
  if (md->memberType()!=MemberType::Define &&
      md->memberType()!=MemberType::Enumeration
     )
  {
    if (md->memberType()!=MemberType::Typedef)
    {
      writeMemberTemplateLists(md);
    }
    DString typeStr = md->typeString();
    stripQualifiers(typeStr);
    StringVector list;
    linkifyText(TextGeneratorSqlite3Impl(list),typeStr,options);
    if (!typeStr.empty())
    {
      bindTextParameter(memberdef_insert,":type",typeStr);
    }
 
    if (!md->definition().empty())
    {
      bindTextParameter(memberdef_insert,":definition",md->definition());
    }
 
    if (!md->argsString().empty())
    {
      bindTextParameter(memberdef_insert,":argsstring",md->argsString());
    }
  }
 
  bindTextParameter(memberdef_insert,":name",md->name());
 
  // Extract references from initializer
  if (md->hasMultiLineInitializer() || md->hasOneLineInitializer())
  {
    bindTextParameter(memberdef_insert,":initializer",md->initializer());
 
    StringVector list;
    linkifyText(TextGeneratorSqlite3Impl(list),md->initializer(),options);
    for (const auto &s : list)
    {
      if (md->getBodyDef())
      {
        DBG_CTX(("initializer:%s %s %s %d\n",
              qPrint(md->anchor()),
              qPrint(s),
              qPrint(md->getBodyDef()->getDefFileName()),
              md->getStartBodyLine()));
        DString qsrc_refid = md->getOutputFileBase() + "_1" + md->anchor();
        struct Refid src_refid = insertRefid(qsrc_refid);
        struct Refid dst_refid = insertRefid(s);
        insertMemberReference(src_refid,dst_refid, "initializer");
      }
    }
  }
 
  if ( !md->getScopeString().empty() )
  {
    bindTextParameter(memberdef_insert,":scope",md->getScopeString());
  }
 
  // +Brief, detailed and inbody description
  getSQLDesc(memberdef_insert,":briefdescription",md->briefDescription(),md);
  getSQLDesc(memberdef_insert,":detaileddescription",md->documentation(),md);
  getSQLDesc(memberdef_insert,":inbodydescription",md->inbodyDocumentation(),md);
 
  // File location
  if (md->getDefLine() != -1)
  {
    int file_id = insertPath(md->getDefFileName(),!md->isReference());
    if (file_id!=-1)
    {
      bindIntParameter(memberdef_insert,":file_id",file_id);
      bindIntParameter(memberdef_insert,":line",md->getDefLine());
      bindIntParameter(memberdef_insert,":column",md->getDefColumn());
 
      // definitions also have bodyfile/start/end
      if (md->getStartBodyLine()!=-1)
      {
        int bodyfile_id = insertPath(md->getBodyDef()->absFilePath(),!md->getBodyDef()->isReference());
        if (bodyfile_id == -1)
        {
            sqlite3_clear_bindings(memberdef_insert.stmt);
        }
        else
        {
            bindIntParameter(memberdef_insert,":bodyfile_id",bodyfile_id);
            bindIntParameter(memberdef_insert,":bodystart",md->getStartBodyLine());
            bindIntParameter(memberdef_insert,":bodyend",md->getEndBodyLine());
        }
      }
    }
  }
 
  int memberdef_id=step(memberdef_insert,true);
 
  if (isFunc)
  {
    insertMemberFunctionParams(memberdef_id,md,def);
  }
  else if (md->memberType()==MemberType::Define &&
          !md->argsString().empty())
  {
    insertMemberDefineParams(memberdef_id,md,def);
  }
 
  // + source references
  // The cross-references in initializers only work when both the src and dst
  // are defined.
  for (const auto &refmd : md->getReferencesMembers())
  {
    insertMemberReference(md,refmd, "inline");
  }
  // + source referenced by
  for (const auto &refmd : md->getReferencedByMembers())
  {
    insertMemberReference(refmd,md, "inline");
  }
}

References FileDef::absFilePath(), Definition::anchor(), MemberDef::argsString(), MemberDef::argumentList(), associateMember(), DString::at(), bindIntParameter(), bindTextParameter(), MemberDef::bitfieldString(), Definition::briefDescription(), ArgumentList::constSpecifier(), DBG_CTX, MemberDef::definition(), Definition::documentation(), DString::empty(), Definition::getBodyDef(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), Definition::getEndBodyLine(), Definition::getOutputFileBase(), MemberDef::getReadAccessor(), Definition::getReferencedByMembers(), Definition::getReferencesMembers(), MemberDef::getScopeString(), getSQLDesc(), Definition::getStartBodyLine(), MemberDef::getWriteAccessor(), MemberDef::hasMultiLineInitializer(), MemberDef::hasOneLineInitializer(), Definition::inbodyDocumentation(), MemberDef::initializer(), insertMemberDefineParams(), insertMemberFunctionParams(), insertMemberReference(), insertPath(), insertRefid(), MemberDef::isAddable(), MemberDef::isAssign(), MemberDef::isAttribute(), MemberDef::isBound(), MemberDef::isConstrained(), MemberDef::isCopy(), MemberDef::isExplicit(), MemberDef::isExternal(), MemberDef::isFinal(), MemberDef::isGettable(), Definition::isHidden(), MemberDef::isInitonly(), MemberDef::isInline(), MemberDef::isMaybeAmbiguous(), MemberDef::isMaybeDefault(), MemberDef::isMaybeVoid(), MemberDef::isMutable(), MemberDef::isNew(), MemberDef::isOptional(), MemberDef::isPrivateGettable(), MemberDef::isPrivateSettable(), MemberDef::isProperty(), MemberDef::isProtectedGettable(), MemberDef::isProtectedSettable(), MemberDef::isRaisable(), MemberDef::isReadable(), MemberDef::isReadonly(), Definition::isReference(), MemberDef::isRemovable(), MemberDef::isRequired(), MemberDef::isRetain(), MemberDef::isSealed(), MemberDef::isSettable(), MemberDef::isStatic(), MemberDef::isStrong(), MemberDef::isThreadLocal(), MemberDef::isTransient(), MemberDef::isWeak(), MemberDef::isWritable(), linkifyText(), memberdef_insert, memberdef_update_decl, memberdef_update_def, memberdefExists(), memberdefIncomplete(), MemberDef::memberType(), MemberDef::memberTypeName(), DString::mid(), Definition::name(), MemberDef::protection(), qPrint(), Refid::refid, MemberDef::reimplements(), reimplements_insert, Refid::rowid, LinkifyTextOptions::setFileScope(), LinkifyTextOptions::setScope(), LinkifyTextOptions::setSelf(), step(), SqlStmt::stmt, stripQualifiers(), DString::stripWhiteSpace(), MemberDef::typeString(), MemberDef::virtualness(), ArgumentList::volatileSpecifier(), and writeMemberTemplateLists().

Referenced by generateSqlite3Section().

generateSqlite3ForModule()

void generateSqlite3ForModule ( const ModuleDef * mod )

static

Definition at line 2076 of file sqlite3gen.cpp.

{
  // + contained class definitions
  // + contained concept definitions
  // + member groups
  // + normal members
  // + brief desc
  // + detailed desc
  // + location (file_id, line, column)
  // - exports
  // + used files
 
  if (mod->isReference() || mod->isHidden()) return;
  struct Refid refid = insertRefid(mod->getOutputFileBase());
  if(!refid.created && compounddefExists(refid)){return;}
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
  bindTextParameter(compounddef_insert,":name",mod->name());
  bindTextParameter(compounddef_insert,":kind","module");
 
  int file_id = insertPath(mod->getDefFileName());
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",mod->getDefLine());
  bindIntParameter(compounddef_insert,":column",mod->getDefColumn());
 
  getSQLDescCompound(compounddef_insert,":briefdescription",mod->briefDescription(),mod);
  getSQLDescCompound(compounddef_insert,":detaileddescription",mod->documentation(),mod);
 
  step(compounddef_insert);
 
  // + contained class definitions
  writeInnerClasses(mod->getClasses(),refid);
 
  // + contained concept definitions
  writeInnerConcepts(mod->getConcepts(),refid);
 
  // + member groups
  for (const auto &mg : mod->getMemberGroups())
  {
    generateSqlite3Section(mod,&mg->members(),refid,"user-defined",mg->header(),
        mg->documentation());
  }
 
  // + normal members
  for (const auto &ml : mod->getMemberLists())
  {
    if (ml->listType().isDeclaration())
    {
      generateSqlite3Section(mod,ml.get(),refid,"user-defined");
    }
  }
 
  // + files
  writeInnerFiles(mod->getUsedFiles(),refid);
}

References bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), Definition::documentation(), generateSqlite3Section(), ModuleDef::getClasses(), ModuleDef::getConcepts(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), ModuleDef::getMemberGroups(), ModuleDef::getMemberLists(), Definition::getOutputFileBase(), getSQLDescCompound(), ModuleDef::getUsedFiles(), insertPath(), insertRefid(), MemberListType::isDeclaration(), Definition::isHidden(), Definition::isReference(), MemberList::listType(), Definition::name(), Refid::refid, step(), writeInnerClasses(), writeInnerConcepts(), and writeInnerFiles().

Referenced by generateSqlite3().

generateSqlite3ForNamespace()

void generateSqlite3ForNamespace ( const NamespaceDef * nd )

static

Definition at line 2132 of file sqlite3gen.cpp.

{
  // + contained class definitions
  // + contained namespace definitions
  // + member groups
  // + normal members
  // + brief desc
  // + detailed desc
  // + location (file_id, line, column)
  // - files containing (parts of) the namespace definition
 
  if (nd->isReference() || nd->isHidden()) return; // skip external references
  struct Refid refid = insertRefid(nd->getOutputFileBase());
  if(!refid.created && compounddefExists(refid)){return;}
  bindIntParameter(compounddef_insert,":rowid", refid.rowid);
 
  bindTextParameter(compounddef_insert,":name",nd->name());
  bindTextParameter(compounddef_insert,":title",nd->title());
  bindTextParameter(compounddef_insert,":kind","namespace");
 
  int file_id = insertPath(nd->getDefFileName());
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",nd->getDefLine());
  bindIntParameter(compounddef_insert,":column",nd->getDefColumn());
 
  getSQLDescCompound(compounddef_insert,":briefdescription",nd->briefDescription(),nd);
  getSQLDescCompound(compounddef_insert,":detaileddescription",nd->documentation(),nd);
 
  step(compounddef_insert);
 
  // + contained class definitions
  writeInnerClasses(nd->getClasses(),refid);
 
  // + contained concept definitions
  writeInnerConcepts(nd->getConcepts(),refid);
 
  // + contained namespace definitions
  writeInnerNamespaces(nd->getNamespaces(),refid);
 
  // + member groups
  for (const auto &mg : nd->getMemberGroups())
  {
    generateSqlite3Section(nd,&mg->members(),refid,"user-defined",mg->header(),
        mg->documentation());
  }
 
  // + normal members
  for (const auto &ml : nd->getMemberLists())
  {
    if (ml->listType().isDeclaration())
    {
      generateSqlite3Section(nd,ml.get(),refid,"user-defined");
    }
  }
}

References bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), Definition::documentation(), generateSqlite3Section(), NamespaceDef::getClasses(), NamespaceDef::getConcepts(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), NamespaceDef::getMemberGroups(), NamespaceDef::getMemberLists(), NamespaceDef::getNamespaces(), Definition::getOutputFileBase(), getSQLDescCompound(), insertPath(), insertRefid(), MemberListType::isDeclaration(), Definition::isHidden(), Definition::isReference(), MemberList::listType(), Definition::name(), Refid::refid, step(), NamespaceDef::title(), writeInnerClasses(), writeInnerConcepts(), and writeInnerNamespaces().

Referenced by generateSqlite3().

generateSqlite3ForPage()

void generateSqlite3ForPage ( const PageDef * pd, bool isExample )

static

Definition at line 2458 of file sqlite3gen.cpp.

{
  // + name
  // + title
  // + brief description
  // + documentation (detailed description)
  // + inbody documentation
  // + sub pages
  if (pd->isReference()) return; // skip external references.
 
  // TODO: do we more special handling if isExample?
 
  DString qrefid = pd->getOutputFileBase();
  if (pd->getGroupDef())
  {
    qrefid+="_"+pd->name();
  }
  if (qrefid=="index") qrefid="indexpage"; // to prevent overwriting the generated index page.
 
  struct Refid refid = insertRefid(qrefid);
 
  // can omit a page that already has a refid
  if(!refid.created && compounddefExists(refid)){return;}
 
  bindIntParameter(compounddef_insert,":rowid",refid.rowid);
  // + name
  bindTextParameter(compounddef_insert,":name",pd->name());
 
  DString title;
  if (pd==Doxygen::mainPage.get()) // main page is special
  {
    if (mainPageHasTitle())
    {
      title = filterTitle(HtmlEntityMapper::instance().convertCharEntitiesToUTF8(Doxygen::mainPage->title()));
    }
    else
    {
      title = Config_getString(PROJECT_NAME);
    }
  }
  else
  {
    SectionInfo *si = SectionManager::instance().find(pd->name());
    if (si)
    {
      title = si->title();
    }
    if (title.empty())
    {
      title = pd->title();
    }
  }
 
  // + title
  bindTextParameter(compounddef_insert,":title",title);
 
  bindTextParameter(compounddef_insert,":kind", isExample ? "example" : "page");
 
  int file_id = insertPath(pd->getDefFileName());
 
  bindIntParameter(compounddef_insert,":file_id",file_id);
  bindIntParameter(compounddef_insert,":line",pd->getDefLine());
  bindIntParameter(compounddef_insert,":column",pd->getDefColumn());
 
  // + brief description
  getSQLDesc(compounddef_insert,":briefdescription",pd->briefDescription(),pd);
  // + documentation (detailed description)
  getSQLDesc(compounddef_insert,":detaileddescription",pd->documentation(),pd);
 
  step(compounddef_insert);
  // + sub pages
  writeInnerPages(pd->getSubPages(),refid);
}

References bindIntParameter(), bindTextParameter(), Definition::briefDescription(), compounddef_insert, compounddefExists(), Config_getString, Definition::documentation(), DString::empty(), filterTitle(), LinkedMap< T, Hash, KeyEqual, Map >::find(), Definition::getDefColumn(), Definition::getDefFileName(), Definition::getDefLine(), PageDef::getGroupDef(), Definition::getOutputFileBase(), getSQLDesc(), PageDef::getSubPages(), insertPath(), insertRefid(), HtmlEntityMapper::instance(), SectionManager::instance(), Definition::isReference(), Doxygen::mainPage, mainPageHasTitle(), Definition::name(), Refid::refid, step(), PageDef::title(), SectionInfo::title(), and writeInnerPages().

Referenced by generateSqlite3().

generateSqlite3Section()

void generateSqlite3Section ( const Definition * d, const MemberList * ml, struct Refid scope_refid, const char * , const DString & = DString(), const DString & = DString() )

static

Definition at line 1868 of file sqlite3gen.cpp.

{
  if (ml==nullptr) return;
  for (const auto &md : *ml)
  {
    // TODO: necessary? just tracking what xmlgen does; xmlgen says:
    // namespace members are also inserted in the file scope, but
    // to prevent this duplication in the XML output, we filter those here.
    if (d->definitionType()!=Definition::TypeFile || md->getNamespaceDef()==nullptr)
    {
      generateSqlite3ForMember(md, scope_refid, d);
    }
  }
}

References Definition::definitionType(), generateSqlite3ForMember(), and Definition::TypeFile.

Referenced by generateSqlite3ForClass(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), and generateSqlite3ForNamespace().

getSQLDesc()

void getSQLDesc ( SqlStmt & s, const char * col, const DString & value, const Definition * def )

static

Definition at line 1446 of file sqlite3gen.cpp.

{
  bindTextParameter(
    s,
    col,
    getSQLDocBlock(
      def->getOuterScope(),
      def,
      value,
      def->docFile(),
      def->docLine()
    )
  );
}

References bindTextParameter(), Definition::docFile(), Definition::docLine(), Definition::getOuterScope(), and getSQLDocBlock().

Referenced by generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForMember(), and generateSqlite3ForPage().

getSQLDescCompound()

void getSQLDescCompound ( SqlStmt & s, const char * col, const DString & value, const Definition * def )

static

Definition at line 1461 of file sqlite3gen.cpp.

{
  bindTextParameter(
    s,
    col,
    getSQLDocBlock(
      def,
      def,
      value,
      def->docFile(),
      def->docLine()
    )
  );
}

References bindTextParameter(), Definition::docFile(), Definition::docLine(), and getSQLDocBlock().

Referenced by generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForModule(), and generateSqlite3ForNamespace().

getSQLDocBlock()

DString getSQLDocBlock	(	const Definition *	scope,
		const Definition *	def,
		const DString &	doc,
		const DString &	fileName,
		int	lineNr )

Definition at line 1415 of file sqlite3gen.cpp.

{
  if (doc.empty()) return "";
 
  TextStream t;
  auto parser { createDocParser() };
  auto ast    { validatingParseDoc(*parser.get(),
                                   fileName,
                                   lineNr,
                                   scope,
                                   toMemberDef(def),
                                   doc,
                                   DocOptions())
              };
  auto astImpl = dynamic_cast<const DocNodeAST*>(ast.get());
  if (astImpl)
  {
    OutputCodeList xmlCodeList;
    xmlCodeList.add<XMLCodeGenerator>(&t);
    // create a parse tree visitor for XML
    XmlDocVisitor visitor(t,xmlCodeList,
        scope ? scope->getDefFileExtension() : DString(""));
    std::visit(visitor,astImpl->root);
  }
  return HtmlEntityMapper::instance().convertCharEntitiesToUTF8(t.str());
}

References OutputCodeList::add(), HtmlEntityMapper::convertCharEntitiesToUTF8(), createDocParser(), DString::empty(), Definition::getDefFileExtension(), HtmlEntityMapper::instance(), TextStream::str(), toMemberDef(), and validatingParseDoc().

Referenced by getSQLDesc(), and getSQLDescCompound().

initializeTables()

int initializeTables ( sqlite3 * db )

static

Definition at line 1217 of file sqlite3gen.cpp.

{
  msg("Initializing DB schema (tables)...\n");
  for (unsigned int k = 0; k < sizeof(table_schema) / sizeof(table_schema[0]); k++)
  {
    const char *q = table_schema[k][1];
    char *errmsg = nullptr;
    int rc = sqlite3_exec(db, q, nullptr, nullptr, &errmsg);
    if (rc != SQLITE_OK)
    {
      err("failed to execute query: {}\n\t{}\n", q, errmsg);
      return -1;
    }
  }
  return 0;
}

References err, msg, and table_schema.

Referenced by generateSqlite3().

initializeViews()

int initializeViews ( sqlite3 * db )

static

Definition at line 1234 of file sqlite3gen.cpp.

{
  msg("Initializing DB schema (views)...\n");
  for (unsigned int k = 0; k < sizeof(view_schema) / sizeof(view_schema[0]); k++)
  {
    const char *q = view_schema[k][1];
    char *errmsg = nullptr;
    int rc = sqlite3_exec(db, q, nullptr, nullptr, &errmsg);
    if (rc != SQLITE_OK)
    {
      err("failed to execute query: {}\n\t{}\n", q, errmsg);
      return -1;
    }
  }
  return 0;
}

References err, msg, and view_schema.

Referenced by generateSqlite3().

insertMemberDefineParams()

void insertMemberDefineParams ( int memberdef_id, const MemberDef * md, const Definition * def )

static

Definition at line 1100 of file sqlite3gen.cpp.

{
    if (md->argumentList().empty()) // special case for "foo()" to
                                    // distinguish it from "foo".
    {
      DBG_CTX(("no params\n"));
    }
    else
    {
      for (const Argument &a : md->argumentList())
      {
        bindTextParameter(param_insert,":defname",a.type);
        int param_id=step(param_insert,true);
        if (param_id==-1) {
          continue;
        }
 
        bindIntParameter(memberdef_param_insert,":memberdef_id",memberdef_id);
        bindIntParameter(memberdef_param_insert,":param_id",param_id);
        step(memberdef_param_insert);
      }
    }
}

References MemberDef::argumentList(), bindIntParameter(), bindTextParameter(), DBG_CTX, ArgumentList::empty(), memberdef_param_insert, param_insert, and step().

Referenced by generateSqlite3ForMember().

insertMemberFunctionParams()

void insertMemberFunctionParams ( int memberdef_id, const MemberDef * md, const Definition * def )

static

Definition at line 1022 of file sqlite3gen.cpp.

{
  LinkifyTextOptions options;
  options.setScope(def).setFileScope(md->getBodyDef()).setSelf(md);
  const ArgumentList &declAl = md->declArgumentList();
  const ArgumentList &defAl = md->argumentList();
  if (declAl.size()>0)
  {
    auto defIt = defAl.begin();
    for (const Argument &a : declAl)
    {
      //const Argument *defArg = defAli.current();
      const Argument *defArg = nullptr;
      if (defIt!=defAl.end())
      {
        defArg = &(*defIt);
        ++defIt;
      }
 
      if (!a.attrib.empty())
      {
        bindTextParameter(param_select,":attributes",a.attrib);
        bindTextParameter(param_insert,":attributes",a.attrib);
      }
      if (!a.type.empty())
      {
        StringVector list;
        linkifyText(TextGeneratorSqlite3Impl(list),a.type,options);
 
        for (const auto &s : list)
        {
          DString qsrc_refid = md->getOutputFileBase() + "_1" + md->anchor();
          struct Refid src_refid = insertRefid(qsrc_refid);
          struct Refid dst_refid = insertRefid(s);
          insertMemberReference(src_refid,dst_refid, "argument");
        }
        bindTextParameter(param_select,":type",a.type);
        bindTextParameter(param_insert,":type",a.type);
      }
      if (!a.name.empty())
      {
        bindTextParameter(param_select,":declname",a.name);
        bindTextParameter(param_insert,":declname",a.name);
      }
      if (defArg && !defArg->name.empty() && defArg->name!=a.name)
      {
        bindTextParameter(param_select,":defname",defArg->name);
        bindTextParameter(param_insert,":defname",defArg->name);
      }
      if (!a.array.empty())
      {
        bindTextParameter(param_select,":array",a.array);
        bindTextParameter(param_insert,":array",a.array);
      }
      if (!a.defval.empty())
      {
        StringVector list;
        linkifyText(TextGeneratorSqlite3Impl(list),a.defval,options);
        bindTextParameter(param_select,":defval",a.defval);
        bindTextParameter(param_insert,":defval",a.defval);
      }
 
      int param_id=step(param_select,true,true);
      if (param_id==0) {
        param_id=step(param_insert,true);
      }
      if (param_id==-1) {
          DBG_CTX(("error INSERT params failed\n"));
          continue;
      }
 
      bindIntParameter(memberdef_param_insert,":memberdef_id",memberdef_id);
      bindIntParameter(memberdef_param_insert,":param_id",param_id);
      step(memberdef_param_insert);
    }
  }
}

References Definition::anchor(), MemberDef::argumentList(), ArgumentList::begin(), bindIntParameter(), bindTextParameter(), DBG_CTX, MemberDef::declArgumentList(), DString::empty(), ArgumentList::end(), Definition::getBodyDef(), Definition::getOutputFileBase(), insertMemberReference(), insertRefid(), linkifyText(), memberdef_param_insert, Argument::name, param_insert, param_select, LinkifyTextOptions::setFileScope(), LinkifyTextOptions::setScope(), LinkifyTextOptions::setSelf(), ArgumentList::size(), and step().

Referenced by generateSqlite3ForMember().

insertMemberReference() [1/2]

void insertMemberReference ( const MemberDef * src, const MemberDef * dst, const char * context )

static

Definition at line 1012 of file sqlite3gen.cpp.

{
  DString qdst_refid = dst->getOutputFileBase() + "_1" + dst->anchor();
  DString qsrc_refid = src->getOutputFileBase() + "_1" + src->anchor();
 
  struct Refid src_refid = insertRefid(qsrc_refid);
  struct Refid dst_refid = insertRefid(qdst_refid);
  insertMemberReference(src_refid,dst_refid,context);
}

References Definition::anchor(), Definition::getOutputFileBase(), insertMemberReference(), and insertRefid().

insertMemberReference() [2/2]

bool insertMemberReference ( struct Refid src_refid, struct Refid dst_refid, const char * context )

static

Definition at line 991 of file sqlite3gen.cpp.

{
  if (src_refid.rowid==-1||dst_refid.rowid==-1)
    return false;
 
  if (
     !bindIntParameter(xrefs_insert,":src_rowid",src_refid.rowid) ||
     !bindIntParameter(xrefs_insert,":dst_rowid",dst_refid.rowid)
     )
  {
    return false;
  }
  else
  {
    bindTextParameter(xrefs_insert,":context",context);
  }
 
  step(xrefs_insert);
  return true;
}

References bindIntParameter(), bindTextParameter(), Refid::rowid, step(), and xrefs_insert.

Referenced by generateSqlite3ForMember(), insertMemberFunctionParams(), and insertMemberReference().

insertPath()

int insertPath ( DString name, bool local = true, bool found = true, int type = 1 )

static

Definition at line 911 of file sqlite3gen.cpp.

{
  int rowid=-1;
  if (name==nullptr) return rowid;
 
  name = stripFromPath(name);
 
  bindTextParameter(path_select,":name",name.data());
  rowid=step(path_select,true,true);
  if (rowid==0)
  {
    bindTextParameter(path_insert,":name",name.data());
    bindIntParameter(path_insert,":type",type);
    bindIntParameter(path_insert,":local",local?1:0);
    bindIntParameter(path_insert,":found",found?1:0);
    rowid=step(path_insert,true);
  }
  return rowid;
}

References bindIntParameter(), bindTextParameter(), DString::data(), path_insert, path_select, step(), and stripFromPath().

Referenced by generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForMember(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), and generateSqlite3ForPage().

insertRefid()

struct Refid insertRefid

(

const DString &

refid

)

Definition at line 949 of file sqlite3gen.cpp.

{
  Refid ret;
  ret.rowid=-1;
  ret.refid=refid;
  ret.created = false;
  if (refid.empty()) return ret;
 
  bindTextParameter(refid_select,":refid",refid);
  ret.rowid=step(refid_select,true,true);
  if (ret.rowid==0)
  {
    bindTextParameter(refid_insert,":refid",refid);
    ret.rowid=step(refid_insert,true);
    ret.created = true;
  }
 
  return ret;
}

References bindTextParameter(), Refid::created, DString::empty(), insertRefid(), Refid::refid, refid_insert, refid_select, Refid::rowid, and step().

Referenced by associateAllClassMembers(), generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForMember(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateSqlite3ForPage(), insertMemberFunctionParams(), insertMemberReference(), insertRefid(), writeInnerClasses(), writeInnerConcepts(), writeInnerDirs(), writeInnerFiles(), writeInnerGroups(), writeInnerModules(), writeInnerNamespaces(), and writeInnerPages().

memberdefExists()

bool memberdefExists ( struct Refid refid )

static

Definition at line 969 of file sqlite3gen.cpp.

{
  bindIntParameter(memberdef_exists,":rowid",refid.rowid);
  int test = step(memberdef_exists,true,true);
  return test ? true : false;
}

References bindIntParameter(), memberdef_exists, Refid::refid, and step().

Referenced by generateSqlite3ForMember().

memberdefIncomplete()

bool memberdefIncomplete ( struct Refid refid, const MemberDef * md )

static

Definition at line 976 of file sqlite3gen.cpp.

{
  bindIntParameter(memberdef_incomplete,":rowid",refid.rowid);
  bindIntParameter(memberdef_incomplete,":new_inline",md->isInline());
  int test = step(memberdef_incomplete,true,true);
  return test ? true : false;
}

References bindIntParameter(), MemberDef::isInline(), memberdef_incomplete, Refid::refid, and step().

Referenced by generateSqlite3ForMember().

openDbConnection()

sqlite3 * openDbConnection ( )

static

Definition at line 2533 of file sqlite3gen.cpp.

{
 
  DString outputDirectory = Config_getString(SQLITE3_OUTPUT);
  sqlite3 *db = nullptr;
 
  int rc = sqlite3_initialize();
  if (rc != SQLITE_OK)
  {
    err("sqlite3_initialize failed\n");
    return nullptr;
  }
 
  std::string dbFileName = "doxygen_sqlite3.db";
  FileInfo fi(outputDirectory.str()+"/"+dbFileName);
 
  if (fi.exists())
  {
    if (Config_getBool(SQLITE3_RECREATE_DB))
    {
       Dir().remove(fi.absFilePath());
    }
    else
    {
      err("doxygen_sqlite3.db already exists! Rename, remove, or archive it to regenerate\n");
      return nullptr;
    }
  }
 
  rc = sqlite3_open_v2(
    fi.absFilePath().c_str(),
    &db,
    SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
    nullptr
  );
  if (rc != SQLITE_OK)
  {
    sqlite3_close(db);
    err("Database open failed: doxygen_sqlite3.db\n");
  }
  return db;
}

References FileInfo::absFilePath(), Config_getBool, Config_getString, err, FileInfo::exists(), Dir::remove(), and DString::str().

Referenced by generateSqlite3().

pragmaTuning()

void pragmaTuning ( sqlite3 * db )

static

Definition at line 1209 of file sqlite3gen.cpp.

{
  char * sErrMsg = nullptr;
  sqlite3_exec(db, "PRAGMA synchronous = OFF", nullptr, nullptr, &sErrMsg);
  sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", nullptr, nullptr, &sErrMsg);
  sqlite3_exec(db, "PRAGMA temp_store = MEMORY;", nullptr, nullptr, &sErrMsg);
}

Referenced by generateSqlite3().

prepareStatement()

int prepareStatement ( sqlite3 * db, SqlStmt & s )

static

Definition at line 1152 of file sqlite3gen.cpp.

{
  int rc = sqlite3_prepare_v2(db,s.query,-1,&s.stmt,nullptr);
  if (rc!=SQLITE_OK)
  {
    err("prepare failed for:\n  {}\n  {}\n", s.query, sqlite3_errmsg(db));
    s.db = nullptr;
    return -1;
  }
  s.db = db;
  return rc;
}

References SqlStmt::db, err, SqlStmt::query, and SqlStmt::stmt.

Referenced by prepareStatements().

prepareStatements()

int prepareStatements ( sqlite3 * db )

static

Definition at line 1165 of file sqlite3gen.cpp.

{
  if (
  -1==prepareStatement(db, meta_insert) ||
  -1==prepareStatement(db, memberdef_exists) ||
  -1==prepareStatement(db, memberdef_incomplete) ||
  -1==prepareStatement(db, memberdef_insert) ||
  -1==prepareStatement(db, memberdef_update_def) ||
  -1==prepareStatement(db, memberdef_update_decl) ||
  -1==prepareStatement(db, member_insert) ||
  -1==prepareStatement(db, path_insert) ||
  -1==prepareStatement(db, path_select) ||
  -1==prepareStatement(db, refid_insert) ||
  -1==prepareStatement(db, refid_select) ||
  -1==prepareStatement(db, incl_insert)||
  -1==prepareStatement(db, incl_select)||
  -1==prepareStatement(db, param_insert) ||
  -1==prepareStatement(db, param_select) ||
  -1==prepareStatement(db, xrefs_insert) ||
  -1==prepareStatement(db, reimplements_insert) ||
  -1==prepareStatement(db, contains_insert) ||
  -1==prepareStatement(db, compounddef_exists) ||
  -1==prepareStatement(db, compounddef_insert) ||
  -1==prepareStatement(db, compoundref_insert) ||
  -1==prepareStatement(db, memberdef_param_insert)
  )
  {
    return -1;
  }
  return 0;
}

References compounddef_exists, compounddef_insert, compoundref_insert, contains_insert, incl_insert, incl_select, member_insert, memberdef_exists, memberdef_incomplete, memberdef_insert, memberdef_param_insert, memberdef_update_decl, memberdef_update_def, meta_insert, param_insert, param_select, path_insert, path_select, prepareStatement(), refid_insert, refid_select, reimplements_insert, and xrefs_insert.

Referenced by generateSqlite3().

recordMetadata()

void recordMetadata ( )

static

Definition at line 931 of file sqlite3gen.cpp.

{
  bindTextParameter(meta_insert,":doxygen_version",getFullVersion());
  bindTextParameter(meta_insert,":schema_version","0.2.1"); //TODO: this should be a constant somewhere; not sure where
  bindTextParameter(meta_insert,":generated_at",dateToString(DateTimeType::DateTime));
  bindTextParameter(meta_insert,":generated_on",dateToString(DateTimeType::Date));
  bindTextParameter(meta_insert,":project_name",Config_getString(PROJECT_NAME));
  bindTextParameter(meta_insert,":project_number",Config_getString(PROJECT_NUMBER));
  bindTextParameter(meta_insert,":project_brief",Config_getString(PROJECT_BRIEF));
  step(meta_insert);
}

References bindTextParameter(), Config_getString, Date, DateTime, dateToString(), meta_insert, and step().

Referenced by generateSqlite3().

step()

int step ( SqlStmt & s, bool getRowId = false, bool select = false )

static

Definition at line 893 of file sqlite3gen.cpp.

{
  int rowid=-1;
  int rc = sqlite3_step(s.stmt);
  if (rc!=SQLITE_DONE && rc!=SQLITE_ROW)
  {
    DBG_CTX(("sqlite3_step: %s (rc: %d)\n", sqlite3_errmsg(s.db), rc));
    sqlite3_reset(s.stmt);
    sqlite3_clear_bindings(s.stmt);
    return -1;
  }
  if (getRowId && select) rowid = sqlite3_column_int(s.stmt, 0); // works on selects, doesn't on inserts
  if (getRowId && !select) rowid = static_cast<int>(sqlite3_last_insert_rowid(s.db)); //works on inserts, doesn't on selects
  sqlite3_reset(s.stmt);
  sqlite3_clear_bindings(s.stmt); // XXX When should this really be called
  return rowid;
}

References SqlStmt::db, DBG_CTX, and SqlStmt::stmt.

Referenced by associateMember(), compounddefExists(), generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForMember(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateSqlite3ForPage(), insertMemberDefineParams(), insertMemberFunctionParams(), insertMemberReference(), insertPath(), insertRefid(), memberdefExists(), memberdefIncomplete(), recordMetadata(), writeInnerClasses(), writeInnerConcepts(), writeInnerDirs(), writeInnerFiles(), writeInnerGroups(), writeInnerModules(), writeInnerNamespaces(), writeInnerPages(), and writeTemplateArgumentList().

stripQualifiers()

void stripQualifiers ( DString & typeStr )

static

Definition at line 1140 of file sqlite3gen.cpp.

{
  bool done=false;
  while (!done)
  {
    if      (typeStr.stripPrefix("static "));
    else if (typeStr.stripPrefix("virtual "));
    else if (typeStr=="virtual") typeStr="";
    else done=true;
  }
}

References DString::stripPrefix().

Referenced by generateSqlite3ForMember().

writeInnerClasses()

void writeInnerClasses ( const ClassLinkedRefMap & cl, struct Refid outer_refid )

static

Definition at line 1264 of file sqlite3gen.cpp.

{
  for (const auto &cd : cl)
  {
    if (!cd->isHidden() && !cd->isAnonymous())
    {
      struct Refid inner_refid = insertRefid(cd->getOutputFileBase());
 
      bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
      bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
      step(contains_insert);
    }
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForClass(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), and generateSqlite3ForNamespace().

writeInnerConcepts()

void writeInnerConcepts ( const ConceptLinkedRefMap & cl, struct Refid outer_refid )

static

Definition at line 1279 of file sqlite3gen.cpp.

{
  for (const auto &cd : cl)
  {
    struct Refid inner_refid = insertRefid(cd->getOutputFileBase());
 
    bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
    bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
    step(contains_insert);
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), and generateSqlite3ForNamespace().

writeInnerDirs()

void writeInnerDirs ( const DirList & dl, struct Refid outer_refid )

static

Definition at line 1342 of file sqlite3gen.cpp.

{
  for (const auto &subdir : dl)
  {
    struct Refid inner_refid = insertRefid(subdir->getOutputFileBase());
 
    bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
    bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
    step(contains_insert);
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForDir().

writeInnerFiles()

void writeInnerFiles ( const FileList & fl, struct Refid outer_refid )

static

Definition at line 1330 of file sqlite3gen.cpp.

{
  for (const auto &fd: fl)
  {
    struct Refid inner_refid = insertRefid(fd->getOutputFileBase());
 
    bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
    bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
    step(contains_insert);
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForDir(), generateSqlite3ForGroup(), and generateSqlite3ForModule().

writeInnerGroups()

void writeInnerGroups ( const GroupList & gl, struct Refid outer_refid )

static

Definition at line 1318 of file sqlite3gen.cpp.

{
  for (const auto &sgd : gl)
  {
    struct Refid inner_refid = insertRefid(sgd->getOutputFileBase());
 
    bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
    bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
    step(contains_insert);
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForGroup().

writeInnerModules()

void writeInnerModules ( const ModuleLinkedRefMap & ml, struct Refid outer_refid )

static

Definition at line 1291 of file sqlite3gen.cpp.

{
  for (const auto &mod : ml)
  {
    struct Refid inner_refid = insertRefid(mod->getOutputFileBase());
 
    bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
    bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
    step(contains_insert);
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForGroup().

writeInnerNamespaces()

void writeInnerNamespaces ( const NamespaceLinkedRefMap & nl, struct Refid outer_refid )

static

Definition at line 1354 of file sqlite3gen.cpp.

{
  for (const auto &nd : nl)
  {
    if (!nd->isHidden() && !nd->isAnonymous())
    {
      struct Refid inner_refid = insertRefid(nd->getOutputFileBase());
 
      bindIntParameter(contains_insert,":inner_rowid",inner_refid.rowid);
      bindIntParameter(contains_insert,":outer_rowid",outer_refid.rowid);
      step(contains_insert);
    }
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForFile(), generateSqlite3ForGroup(), and generateSqlite3ForNamespace().

writeInnerPages()

void writeInnerPages ( const PageLinkedRefMap & pl, struct Refid outer_refid )

static

Definition at line 1304 of file sqlite3gen.cpp.

{
  for (const auto &pd : pl)
  {
    struct Refid inner_refid = insertRefid(
      pd->getGroupDef() ? pd->getOutputFileBase()+"_"+pd->name() : pd->getOutputFileBase()
    );
 
    bindIntParameter(contains_insert,":inner_rowid", inner_refid.rowid);
    bindIntParameter(contains_insert,":outer_rowid", outer_refid.rowid);
    step(contains_insert);
  }
}

References bindIntParameter(), contains_insert, insertRefid(), Refid::rowid, and step().

Referenced by generateSqlite3ForGroup(), and generateSqlite3ForPage().

writeMemberTemplateLists()

void writeMemberTemplateLists ( const MemberDef * md )

static

Definition at line 1400 of file sqlite3gen.cpp.

{
  writeTemplateArgumentList(md->templateArguments(),md->getClassDef(),md->getFileDef());
}

References MemberDef::getClassDef(), MemberDef::getFileDef(), MemberDef::templateArguments(), and writeTemplateArgumentList().

Referenced by generateSqlite3ForMember().

writeTemplateArgumentList()

void writeTemplateArgumentList ( const ArgumentList & al, const Definition * scope, const FileDef * fileScope )

static

Definition at line 1370 of file sqlite3gen.cpp.

{
  for (const Argument &a : al)
  {
    if (!a.type.empty())
    {
//#warning linkifyText(TextGeneratorXMLImpl(t),a.type,LinkifyTextOptions().setScope(scope).setFileScope(fileScope));
      bindTextParameter(param_select,":type",a.type);
      bindTextParameter(param_insert,":type",a.type);
    }
    if (!a.name.empty())
    {
      bindTextParameter(param_select,":declname",a.name);
      bindTextParameter(param_insert,":declname",a.name);
      bindTextParameter(param_select,":defname",a.name);
      bindTextParameter(param_insert,":defname",a.name);
    }
    if (!a.defval.empty())
    {
//#warning linkifyText(TextGeneratorXMLImpl(t),a.defval,LinkifyTextOptions().setScope(scope).setFileScope(fileScope));
      bindTextParameter(param_select,":defval",a.defval);
      bindTextParameter(param_insert,":defval",a.defval);
    }
    if (!step(param_select,true,true))
      step(param_insert);
  }
}

References bindTextParameter(), param_insert, param_select, and step().

Referenced by writeMemberTemplateLists(), writeTemplateList(), and writeTemplateList().

writeTemplateList() [1/2]

void writeTemplateList ( const ClassDef * cd )

static

Definition at line 1405 of file sqlite3gen.cpp.

{
  writeTemplateArgumentList(cd->templateArguments(),cd,cd->getFileDef());
}

References ClassDef::getFileDef(), ClassDef::templateArguments(), and writeTemplateArgumentList().

Referenced by generateSqlite3ForClass(), and generateSqlite3ForConcept().

writeTemplateList() [2/2]

void writeTemplateList ( const ConceptDef * cd )

static

Definition at line 1410 of file sqlite3gen.cpp.

{
  writeTemplateArgumentList(cd->getTemplateParameterList(),cd,cd->getFileDef());
}

References ConceptDef::getFileDef(), ConceptDef::getTemplateParameterList(), and writeTemplateArgumentList().

Variable Documentation

compounddef_exists

SqlStmt compounddef_exists

Initial value:

                          ={
  "SELECT EXISTS ("
    "SELECT * FROM compounddef WHERE rowid = :rowid"
  ")"
  ,nullptr
}

Definition at line 787 of file sqlite3gen.cpp.

Referenced by compounddefExists(), and prepareStatements().

compounddef_insert

SqlStmt compounddef_insert

Definition at line 756 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForClass(), generateSqlite3ForConcept(), generateSqlite3ForDir(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateSqlite3ForPage(), and prepareStatements().

compoundref_insert

SqlStmt compoundref_insert

Initial value:

                          ={
  "INSERT INTO compoundref "
    "( base_rowid, derived_rowid, prot, virt ) "
  "VALUES "
    "(:base_rowid,:derived_rowid,:prot,:virt )"
  ,nullptr
}

Definition at line 794 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForClass(), and prepareStatements().

contains_insert

SqlStmt contains_insert

Initial value:

                       ={
  "INSERT INTO contains "
    "( inner_rowid, outer_rowid )"
  "VALUES "
    "(:inner_rowid,:outer_rowid )"
  ,nullptr
}

Definition at line 533 of file sqlite3gen.cpp.

Referenced by prepareStatements(), writeInnerClasses(), writeInnerConcepts(), writeInnerDirs(), writeInnerFiles(), writeInnerGroups(), writeInnerModules(), writeInnerNamespaces(), and writeInnerPages().

incl_insert

SqlStmt incl_insert

Initial value:

                    = {
  "INSERT INTO includes "
    "( local, src_id, dst_id ) "
  "VALUES "
    "(:local,:src_id,:dst_id )"
  ,nullptr
}

Definition at line 520 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForFile(), and prepareStatements().

incl_select

SqlStmt incl_select

Initial value:

                    = {
  "SELECT COUNT(*) FROM includes WHERE "
  "local=:local AND src_id=:src_id AND dst_id=:dst_id"
  ,nullptr
}

Definition at line 527 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForFile(), and prepareStatements().

member_insert

SqlStmt member_insert

Initial value:

                     ={
  "INSERT INTO member "
    "( scope_rowid, memberdef_rowid, prot, virt ) "
  "VALUES "
    "(:scope_rowid,:memberdef_rowid,:prot,:virt )"
  ,nullptr
}

Definition at line 748 of file sqlite3gen.cpp.

Referenced by associateMember(), and prepareStatements().

memberdef_exists

SqlStmt memberdef_exists

Initial value:

                        ={
  "SELECT EXISTS (SELECT * FROM memberdef WHERE rowid = :rowid)"
  ,nullptr
}

Definition at line 580 of file sqlite3gen.cpp.

Referenced by memberdefExists(), and prepareStatements().

memberdef_incomplete

SqlStmt memberdef_incomplete

Initial value:

                            ={
  "SELECT EXISTS ("
    "SELECT * FROM memberdef WHERE "
    "rowid = :rowid AND inline != 2 AND inline != :new_inline"
  ")"
  ,nullptr
}

Definition at line 585 of file sqlite3gen.cpp.

Referenced by memberdefIncomplete(), and prepareStatements().

memberdef_insert

SqlStmt memberdef_insert

Definition at line 593 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForMember(), and prepareStatements().

memberdef_param_insert

SqlStmt memberdef_param_insert

Initial value:

                              ={
  "INSERT INTO memberdef_param "
    "( memberdef_id, param_id)"
  "VALUES "
    "(:memberdef_id,:param_id)"
  ,nullptr
}

Definition at line 821 of file sqlite3gen.cpp.

Referenced by insertMemberDefineParams(), insertMemberFunctionParams(), and prepareStatements().

memberdef_update_decl

SqlStmt memberdef_update_decl

Initial value:

                             ={
  "UPDATE memberdef SET "
    "inline = :inline,"
    "file_id = :file_id,"
    "line = :line,"
    "column = :column,"
    "detaileddescription = 'Declaration: ' || :detaileddescription || 'Definition: ' || detaileddescription,"
    "briefdescription = 'Declaration: ' || :briefdescription || 'Definition: ' || briefdescription,"
    "inbodydescription = 'Declaration: ' || :inbodydescription || 'Definition: ' || inbodydescription "
  "WHERE rowid = :rowid"
  ,nullptr
}

Definition at line 723 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForMember(), and prepareStatements().

memberdef_update_def

SqlStmt memberdef_update_def

Initial value:

                            ={
  "UPDATE memberdef SET "
    "inline = :inline,"
    "bodystart = :bodystart,"
    "bodyend = :bodyend,"
    "bodyfile_id = :bodyfile_id,"
    "detaileddescription = 'Declaration: ' || detaileddescription || 'Definition: ' || :detaileddescription,"
    "briefdescription = 'Declaration: ' || briefdescription || 'Definition: ' || :briefdescription,"
    "inbodydescription = 'Declaration: ' || inbodydescription || 'Definition: ' || :inbodydescription "
  "WHERE rowid = :rowid"
  ,nullptr
}

Definition at line 735 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForMember(), and prepareStatements().

meta_insert

SqlStmt meta_insert

Initial value:

                    = {
  "INSERT INTO meta "
    "( doxygen_version, schema_version, generated_at, generated_on, project_name, project_number, project_brief )"
  "VALUES "
    "(:doxygen_version,:schema_version,:generated_at,:generated_on,:project_name,:project_number,:project_brief )"
  ,nullptr
}

Definition at line 512 of file sqlite3gen.cpp.

Referenced by prepareStatements(), and recordMetadata().

param_insert

SqlStmt param_insert

Initial value:

                     = {
  "INSERT INTO param "
    "( attributes, type, declname, defname, array, defval, briefdescription ) "
  "VALUES "
    "(:attributes,:type,:declname,:defname,:array,:defval,:briefdescription)"
  ,nullptr
}

Definition at line 813 of file sqlite3gen.cpp.

Referenced by insertMemberDefineParams(), insertMemberFunctionParams(), prepareStatements(), and writeTemplateArgumentList().

param_select

SqlStmt param_select

Initial value:

                     = {
  "SELECT rowid FROM param WHERE "
    "(attributes IS NULL OR attributes=:attributes) AND "
    "(type IS NULL OR type=:type) AND "
    "(declname IS NULL OR declname=:declname) AND "
    "(defname IS NULL OR defname=:defname) AND "
    "(array IS NULL OR array=:array) AND "
    "(defval IS NULL OR defval=:defval) AND "
    "(briefdescription IS NULL OR briefdescription=:briefdescription)"
  ,nullptr
}

Definition at line 802 of file sqlite3gen.cpp.

Referenced by insertMemberFunctionParams(), prepareStatements(), and writeTemplateArgumentList().

path_insert

SqlStmt path_insert

Initial value:

                    = {
  "INSERT INTO path "
    "( type, local, found, name )"
  "VALUES "
    "(:type,:local,:found,:name )"
  ,nullptr
}

Definition at line 545 of file sqlite3gen.cpp.

Referenced by insertPath(), and prepareStatements().

path_select

SqlStmt path_select

Initial value:

                    = {
  "SELECT rowid FROM path WHERE name=:name"
  ,nullptr
}

Definition at line 541 of file sqlite3gen.cpp.

Referenced by insertPath(), and prepareStatements().

refid_insert

SqlStmt refid_insert

Initial value:

                     = {
  "INSERT INTO refid "
    "( refid )"
  "VALUES "
    "(:refid )"
  ,nullptr
}

Definition at line 557 of file sqlite3gen.cpp.

Referenced by insertRefid(), and prepareStatements().

refid_select

SqlStmt refid_select

Initial value:

                     =  {
  "SELECT rowid FROM refid WHERE refid=:refid"
  ,nullptr
}

Definition at line 553 of file sqlite3gen.cpp.

Referenced by insertRefid(), and prepareStatements().

reimplements_insert

SqlStmt reimplements_insert

Initial value:

                           = {
  "INSERT INTO reimplements "
    "( memberdef_rowid, reimplemented_rowid )"
  "VALUES "
    "(:memberdef_rowid,:reimplemented_rowid )"
  ,nullptr
}

Definition at line 572 of file sqlite3gen.cpp.

Referenced by generateSqlite3ForMember(), and prepareStatements().

table_schema

const char* table_schema[][2]

Definition at line 70 of file sqlite3gen.cpp.

Referenced by initializeTables().

view_schema

const char* view_schema[][2]

Definition at line 295 of file sqlite3gen.cpp.

Referenced by initializeViews().

xrefs_insert

SqlStmt xrefs_insert

Initial value:

                    = {
  "INSERT INTO xrefs "
    "( src_rowid, dst_rowid, context )"
  "VALUES "
    "(:src_rowid,:dst_rowid,:context )"
  ,nullptr
}

Definition at line 565 of file sqlite3gen.cpp.

Referenced by insertMemberReference(), and prepareStatements().