/******************************************************************************

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby

 * granted. No representations are made about the suitability of this software

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#include <stdlib.h>

#include <stdio.h>

#include "settings.h"

#include "message.h"

#if USE_SQLITE3

#include "qtbc.h"

#include "sqlite3gen.h"

#include "doxygen.h"

#include "config.h"

#include "util.h"

#include "docparser.h"

#include "language.h"

#include "dot.h"

#include "arguments.h"

#include "classlist.h"

#include "filedef.h"

#include "namespacedef.h"

#include "filename.h"

#include "groupdef.h"

#include "pagedef.h"

#include "dirdef.h"

#include <qdir.h>

#include <string.h>

#include <sqlite3.h>

//#define DBG_CTX(x) printf x

#define DBG_CTX(x) do { } while(0)

const char * schema_queries[][2] = {

  { "includes",

    "CREATE TABLE IF NOT EXISTS includes (\n"

      "\t-- #include relations.\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\tlocal        INTEGER NOT NULL,\n"

      "\tid_src       INTEGER NOT NULL,  -- File id of the includer.\n"

      "\tid_dst       INTEGER NOT NULL   -- File id of the includee.\n"

      ");\n"

    "CREATE UNIQUE INDEX idx_includes ON includes\n"

      "\t(local, id_src, id_dst);"

  },

  { "innerclass",

    "CREATE TABLE IF NOT EXISTS innerclass (\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\trefid        INTEGER NOT NULL,\n"

      "\tprot         INTEGER NOT NULL,\n"

      "\tname         TEXT NOT NULL\n"

      ");"

  },

  { "files",

    "CREATE TABLE IF NOT EXISTS files (\n"

      "\t-- Names of source files and includes.\n"

      "\tname         TEXT PRIMARY KEY NOT NULL\n"

      ");"

  },

  { "refids",

    "CREATE TABLE IF NOT EXISTS refids (\n"

      "\trefid        TEXT PRIMARY KEY NOT NULL\n"

      ");"

  },

  { "xrefs",

    "CREATE TABLE IF NOT EXISTS xrefs (\n"

      "\t-- Cross reference relation.\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\trefid_src    INTEGER NOT NULL, -- referrer id.\n"

      "\trefid_dst    INTEGER NOT NULL, -- referee id.\n"

      "\tid_file      INTEGER NOT NULL, -- file where the reference is happening.\n"

      "\tline         INTEGER NOT NULL, -- line where the reference is happening.\n"

      "\tcolumn       INTEGER NOT NULL  -- column where the reference is happening.\n"

      ");\n"

    "CREATE UNIQUE INDEX idx_xrefs ON xrefs\n"

      "\t(refid_src, refid_dst, id_file, line, column);"

  },

  { "memberdef",

    "CREATE TABLE IF NOT EXISTS memberdef (\n"

      "\t-- All processed identifiers.\n"

      "\trowid                INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\trefid                INTEGER NOT NULL,  -- see the refids table\n"

      "\tname                 TEXT NOT NULL,\n"

      "\tdefinition           TEXT,\n"

      "\ttype                 TEXT,\n"

      "\targsstring           TEXT,\n"

      "\tscope                TEXT,\n"

      "\tinitializer          TEXT,\n"

      "\tbitfield             TEXT,\n"

      "\tread                 TEXT,\n"

      "\twrite                TEXT,\n"

      "\tprot                 INTEGER DEFAULT 0, -- 0:public 1:protected 2:private 3:package\n"

      "\tstatic               INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tconst                INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\texplicit             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tinline               INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tfinal                INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tsealed               INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tnew                  INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\toptional             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\trequired             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tvolatile             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tvirt                 INTEGER DEFAULT 0, -- 0:no 1:virtual 2:pure-virtual\n"

      "\tmutable              INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tinitonly             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tattribute            INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tproperty             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\treadonly             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tbound                INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tconstrained          INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\ttransient            INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tmaybevoid            INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tmaybedefault         INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tmaybeambiguous       INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\treadable             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\twritable             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tgettable             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tprivategettable      INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tprotectedgettable    INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tsettable             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tprivatesettable      INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tprotectedsettable    INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\taccessor             INTEGER DEFAULT 0, -- 0:no 1:assign 2:copy 3:retain 4:string 5:weak\n"

      "\taddable              INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\tremovable            INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      "\traisable             INTEGER DEFAULT 0, -- 0:no 1:yes\n"

      /// @todo make a `kind' table

      "\tkind                 INTEGER DEFAULT 0, -- 0:define 1:function 2:variable 3:typedef 4:enum 5:enumvalue 6:signal 7:slot 8:friend 9:DCOP 10:property 11:event\n"

      "\tbodystart            INTEGER DEFAULT 0, -- starting line of definition\n"

      "\tbodyend              INTEGER DEFAULT 0, -- ending line of definition\n"

      "\tid_bodyfile          INTEGER DEFAULT 0, -- file of definition\n"

      "\tid_file              INTEGER NOT NULL,  -- file where this identifier is located\n"

      "\tline                 INTEGER NOT NULL,  -- line where this identifier is located\n"

      "\tcolumn               INTEGER NOT NULL,  -- column where this identifier is located\n"

      /// @todo make a `detaileddescription' table

      "\tdetaileddescription  TEXT,\n"

      "\tbriefdescription     TEXT,\n"

      "\tinbodydescription    TEXT\n"

      ");"

  },

  { "compounddef",

    "CREATE TABLE IF NOT EXISTS compounddef (\n"

      "\t-- class/struct definitions.\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\tname         TEXT NOT NULL,\n"

      "\tkind         TEXT NOT NULL,\n"

      "\trefid        INTEGER NOT NULL,\n"

      "\tprot         INTEGER NOT NULL,\n"

      "\tid_file      INTEGER NOT NULL,\n"

      "\tline         INTEGER NOT NULL,\n"

      "\tcolumn       INTEGER NOT NULL\n"

      ");"

  },

  { "basecompoundref",

    "CREATE TABLE IF NOT EXISTS basecompoundref (\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\tbase         TEXT NOT NULL,\n"

      "\tderived      TEXT NOT NULL,\n"

      "\trefid        INTEGER NOT NULL,\n"

      "\tprot         INTEGER NOT NULL,\n"

      "\tvirt         INTEGER NOT NULL\n"

      ");"

  },

  { "derivedcompoundref",

    "CREATE TABLE IF NOT EXISTS derivedcompoundref (\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\tbase         TEXT NOT NULL,\n"

      "\tderived      TEXT NOT NULL,\n"

      "\trefid        INTEGER NOT NULL,\n"

      "\tprot         INTEGER NOT NULL,\n"

      "\tvirt         INTEGER NOT NULL\n"

      ");"

  },

  { "params",

    "CREATE TABLE IF NOT EXISTS params (\n"

      "\t-- All processed parameters.\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\tattributes   TEXT,\n"

      "\ttype         TEXT,\n"

      "\tdeclname     TEXT,\n"

      "\tdefname      TEXT,\n"

      "\tarray        TEXT,\n"

      "\tdefval       TEXT,\n"

      "\tbriefdescription TEXT\n"

      ");"

    "CREATE UNIQUE INDEX idx_params ON params\n"

      "\t(type, defname);"

  },

  { "memberdef_params",

    "CREATE TABLE IF NOT EXISTS memberdef_params (\n"

      "\t-- Junction table for memberdef parameters.\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\tid_memberdef INTEGER NOT NULL,\n"

      "\tid_param     INTEGER NOT NULL\n"

      ");"

  },

  { "innernamespaces",

    "CREATE TABLE IF NOT EXISTS innernamespaces (\n"

      "\trowid        INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"

      "\trefid        INTEGER NOT NULL,\n"

      "\tname         TEXT NOT NULL\n"

      ");"

  }

};

//////////////////////////////////////////////////////

struct SqlStmt {

  const char   *query;

  sqlite3_stmt *stmt;

  sqlite3 *db;

};

//////////////////////////////////////////////////////

SqlStmt incl_insert = { "INSERT INTO includes "

  "( local, id_src, id_dst ) "

    "VALUES "

    "(:local,:id_src,:id_dst )"

    ,NULL

};

SqlStmt incl_select = { "SELECT COUNT(*) FROM includes WHERE "

  "local=:local AND id_src=:id_src AND id_dst=:id_dst"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt innerclass_insert={"INSERT INTO innerclass "

    "( refid, prot, name )"

    "VALUES "

    "(:refid,:prot,:name )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt files_select = {"SELECT rowid FROM files WHERE name=:name"

  ,NULL

};

SqlStmt files_insert = {"INSERT INTO files "

  "( name )"

    "VALUES "

    "(:name )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt refids_select =  {"SELECT rowid FROM refids WHERE "

  "refid=:refid"

    ,NULL

};

SqlStmt refids_insert = {"INSERT INTO refids "

  "( refid )"

    "VALUES "

    "(:refid )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt xrefs_insert= {"INSERT INTO xrefs "

  "( refid_src, refid_dst, id_file, line, column )"

    "VALUES "

    "(:refid_src,:refid_dst,:id_file,:line,:column )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt memberdef_insert={"INSERT INTO memberdef "

    "("

      "refid,"

      "name,"

      "definition,"

      "type,"

      "argsstring,"

      "scope,"

      "initializer,"

      "bitfield,"

      "read,"

      "write,"

      "prot,"

      "static,"

      "const,"

      "explicit,"

      "inline,"

      "final,"

      "sealed,"

      "new,"

      "optional,"

      "required,"

      "volatile,"

      "virt,"

      "mutable,"

      "initonly,"

      "attribute,"

      "property,"

      "readonly,"

      "bound,"

      "constrained,"

      "transient,"

      "maybevoid,"

      "maybedefault,"

      "maybeambiguous,"

      "readable,"

      "writable,"

      "gettable,"

      "protectedsettable,"

      "protectedgettable,"

      "settable,"

      "privatesettable,"

      "privategettable,"

      "accessor,"

      "addable,"

      "removable,"

      "raisable,"

      "kind,"

      "bodystart,"

      "bodyend,"

      "id_bodyfile,"

      "id_file,"

      "line,"

      "column,"

      "detaileddescription,"

      "briefdescription,"

      "inbodydescription"

    ")"

    "VALUES "

    "("

      ":refid,"

      ":name,"

      ":definition,"

      ":type,"

      ":argsstring,"

      ":scope,"

      ":initializer,"

      ":bitfield,"

      ":read,"

      ":write,"

      ":prot,"

      ":static,"

      ":const,"

      ":explicit,"

      ":inline,"

      ":final,"

      ":sealed,"

      ":new,"

      ":optional,"

      ":required,"

      ":volatile,"

      ":virt,"

      ":mutable,"

      ":initonly,"

      ":attribute,"

      ":property,"

      ":readonly,"

      ":bound,"

      ":constrained,"

      ":transient,"

      ":maybevoid,"

      ":maybedefault,"

      ":maybeambiguous,"

      ":readable,"

      ":writable,"

      ":gettable,"

      ":protectedsettable,"

      ":protectedgettable,"

      ":settable,"

      ":privatesettable,"

      ":privategettable,"

      ":accessor,"

      ":addable,"

      ":removable,"

      ":raisable,"

      ":kind,"

      ":bodystart,"

      ":bodyend,"

      ":id_bodyfile,"

      ":id_file,"

      ":line,"

      ":column,"

      ":detaileddescription,"

      ":briefdescription,"

      ":inbodydescription"

    ")"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt compounddef_insert={"INSERT INTO compounddef "

    "( name, kind, prot, refid, id_file, line, column ) "

    "VALUES "

    "(:name,:kind,:prot,:refid,:id_file,:line,:column )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt basecompoundref_insert={"INSERT INTO  basecompoundref "

    "( base, derived, refid, prot, virt ) "

    "VALUES "

    "(:base,:derived,:refid,:prot,:virt )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt derivedcompoundref_insert={"INSERT INTO  derivedcompoundref "

    "( refid, prot, virt, base, derived ) "

    "VALUES "

    "(:refid,:prot,:virt,:base,:derived )"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt params_select = { "SELECT rowid FROM  params 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)"

    ,NULL

};

SqlStmt params_insert = { "INSERT INTO  params "

  "( attributes, type, declname, defname, array, defval, briefdescription ) "

    "VALUES "

    "(:attributes,:type,:declname,:defname,:array,:defval,:briefdescription)"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt memberdef_params_insert={ "INSERT INTO  memberdef_params "

    "( id_memberdef, id_param)"

    "VALUES "

    "(:id_memberdef,:id_param)"

    ,NULL

};

//////////////////////////////////////////////////////

SqlStmt innernamespace_insert={"INSERT INTO  innernamespaces "

    "( refid, name)"

    "VALUES "

    "(:refid,:name)",

    NULL

};

class TextGeneratorSqlite3Impl : public TextGeneratorIntf

{

  public:

    TextGeneratorSqlite3Impl(StringList &l) : l(l) {

      l.setAutoDelete(TRUE);

    }

    void writeString(const char * /*s*/,bool /*keepSpaces*/) const

    {

    }

    void writeBreak(int) const

    {

      DBG_CTX(("writeBreak\n"));

    }

    void writeLink(const char * /*extRef*/,const char *file,

                   const char *anchor,const char * /*text*/

                  ) const

    {

      QCString *rs=new QCString(file);

      if (anchor)

      {

        rs->append("_1").append(anchor);

      }

      l.append(rs);

    }

  private:

    StringList &l;

    // the list is filled by linkifyText and consumed by the caller

};

static bool bindTextParameter(SqlStmt &s,const char *name,const char *value, bool _static=TRUE)

{

  int idx = sqlite3_bind_parameter_index(s.stmt, name);

  if (idx==0) {

    msg("sqlite3_bind_parameter_index(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));

    return false;

  }

  int rv = sqlite3_bind_text(s.stmt, idx, value, -1, _static==TRUE?SQLITE_STATIC:SQLITE_TRANSIENT);

  if (rv!=SQLITE_OK) {

    msg("sqlite3_bind_text(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));

    return false;

  }

  return true;

}

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

{

  int idx = sqlite3_bind_parameter_index(s.stmt, name);

  if (idx==0) {

    msg("sqlite3_bind_parameter_index(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));

    return false;

  }

  int rv = sqlite3_bind_int(s.stmt, idx, value);

  if (rv!=SQLITE_OK) {

    msg("sqlite3_bind_int(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));

    return false;

  }

  return true;

}

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

{

  int rowid=-1;

  int rc = sqlite3_step(s.stmt);

  if (rc!=SQLITE_DONE && rc!=SQLITE_ROW)

  {

    msg("sqlite3_step: %s\n", sqlite3_errmsg(s.db));

    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 = 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;

}

static int insertFile(const char* name)

{

  int rowid=-1;

  if (name==0) return rowid;

  bindTextParameter(files_select,":name",name);

  rowid=step(files_select,TRUE,TRUE);

  if (rowid==0)

  {

    bindTextParameter(files_insert,":name",name);

    rowid=step(files_insert,TRUE);

  }

  return rowid;

}

static int insertRefid(const char *refid)

{

  int rowid=-1;

  if (refid==0) return rowid;

  bindTextParameter(refids_select,":refid",refid);

  rowid=step(refids_select,TRUE,TRUE);

  if (rowid==0)

  {

    bindTextParameter(refids_insert,":refid",refid);

    rowid=step(refids_insert,TRUE);

  }

  return rowid;

}

static bool insertMemberReference(int refid_src, int refid_dst,

                                  int id_file, int line, int column)

{

  if (id_file==-1||refid_src==-1||refid_dst==-1)

    return false;

  if (

     !bindIntParameter(xrefs_insert,":refid_src",refid_src) ||

     !bindIntParameter(xrefs_insert,":refid_dst",refid_dst) ||

     !bindIntParameter(xrefs_insert,":id_file",id_file) ||

     !bindIntParameter(xrefs_insert,":line",line) ||

     !bindIntParameter(xrefs_insert,":column",column)

     )

  {

    return false;

  }

  step(xrefs_insert);

  return true;

}

static void insertMemberReference(const MemberDef *src, const MemberDef *dst)

{

  QCString qrefid_dst = dst->getOutputFileBase() + "_1" + dst->anchor();

  QCString qrefid_src = src->getOutputFileBase() + "_1" + src->anchor();

  if (dst->getStartBodyLine()!=-1 && dst->getBodyDef())

  {

    int refid_src = insertRefid(qrefid_src.data());

    int refid_dst = insertRefid(qrefid_dst.data());

    int id_file = insertFile("no-file"); // TODO: replace no-file with proper file

    insertMemberReference(refid_src,refid_dst,id_file,dst->getStartBodyLine(),-1);

  }

}

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

{

  ArgumentList *declAl = md->declArgumentList();

  ArgumentList *defAl = md->argumentList();

  if (declAl!=0 && declAl->count()>0)

  {

    ArgumentListIterator declAli(*declAl);

    ArgumentListIterator defAli(*defAl);

    Argument *a;

    for (declAli.toFirst();(a=declAli.current());++declAli)

    {

      Argument *defArg = defAli.current();

      if (!a->attrib.isEmpty())

      {

        bindTextParameter(params_select,":attributes",a->attrib.data());

        bindTextParameter(params_insert,":attributes",a->attrib.data());

      }

      if (!a->type.isEmpty())

      {

        StringList l;

        linkifyText(TextGeneratorSqlite3Impl(l),def,md->getBodyDef(),md,a->type);

        StringListIterator li(l);

        QCString *s;

        while ((s=li.current()))

        {

          QCString qrefid_src = md->getOutputFileBase() + "_1" + md->anchor();

          int refid_src = insertRefid(qrefid_src.data());

          int refid_dst = insertRefid(s->data());

          int id_file = insertFile(stripFromPath(def->getDefFileName()));

          insertMemberReference(refid_src,refid_dst,id_file,md->getDefLine(),-1);

          ++li;

        }

        bindTextParameter(params_select,":type",a->type.data());

        bindTextParameter(params_insert,":type",a->type.data());

      }

      if (!a->name.isEmpty())

      {

        bindTextParameter(params_select,":declname",a->name.data());

        bindTextParameter(params_insert,":declname",a->name.data());

      }

      if (defArg && !defArg->name.isEmpty() && defArg->name!=a->name)

      {

        bindTextParameter(params_select,":defname",defArg->name.data());

        bindTextParameter(params_insert,":defname",defArg->name.data());

      }

      if (!a->array.isEmpty())

      {

        bindTextParameter(params_select,":array",a->array.data());

        bindTextParameter(params_insert,":array",a->array.data());

      }

      if (!a->defval.isEmpty())

      {

        StringList l;

        linkifyText(TextGeneratorSqlite3Impl(l),def,md->getBodyDef(),md,a->defval);

        bindTextParameter(params_select,":defval",a->defval.data());

        bindTextParameter(params_insert,":defval",a->defval.data());

      }

      if (defArg) ++defAli;

      int id_param=step(params_select,TRUE,TRUE);

      if (id_param==0) {

        id_param=step(params_insert,TRUE);

      }

      if (id_param==-1) {

          msg("error INSERT params failed\n");

          continue;

      }

      bindIntParameter(memberdef_params_insert,":id_memberdef",id_memberdef);

      bindIntParameter(memberdef_params_insert,":id_param",id_param);

      step(memberdef_params_insert);

    }

  }

}

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

{

    if (md->argumentList()->count()==0) // special case for "foo()" to

                                        // disguish it from "foo".

    {

      DBG_CTX(("no params\n"));

    }

    else

    {

      ArgumentListIterator ali(*md->argumentList());

      Argument *a;

      for (ali.toFirst();(a=ali.current());++ali)

      {

        bindTextParameter(params_insert,":defname",a->type.data());

        int id_param=step(params_insert,TRUE);

        if (id_param==-1) {

          msg("error INSERT param(%s) failed\n", a->type.data());

          continue;

        }

        bindIntParameter(memberdef_params_insert,":id_memberdef",id_memberdef);

        bindIntParameter(memberdef_params_insert,":id_param",id_param);

        step(memberdef_params_insert);

      }

    }

}

static void stripQualifiers(QCString &typeStr)

{

  bool done=FALSE;

  while (!done)

  {

    if      (typeStr.stripPrefix("static "));

    else if (typeStr.stripPrefix("virtual "));

    else if (typeStr.stripPrefix("volatile "));

    else if (typeStr=="virtual") typeStr="";

    else done=TRUE;

  }

}

static int prepareStatement(sqlite3 *db, SqlStmt &s)

{

  int rc;

  rc = sqlite3_prepare_v2(db,s.query,-1,&s.stmt,0);

  if (rc!=SQLITE_OK)

  {

    msg("prepare failed for %s\n%s\n", s.query, sqlite3_errmsg(db));

    s.db = NULL;

    return -1;

  }

  s.db = db;

  return rc;

}

static int prepareStatements(sqlite3 *db)

{

  if (

  -1==prepareStatement(db, memberdef_insert) ||

  -1==prepareStatement(db, files_insert) ||

  -1==prepareStatement(db, files_select) ||

  -1==prepareStatement(db, refids_insert) ||

  -1==prepareStatement(db, refids_select) ||

  -1==prepareStatement(db, incl_insert)||

  -1==prepareStatement(db, incl_select)||

  -1==prepareStatement(db, params_insert) ||

  -1==prepareStatement(db, params_select) ||

  -1==prepareStatement(db, xrefs_insert) ||

  -1==prepareStatement(db, innerclass_insert) ||

  -1==prepareStatement(db, compounddef_insert) ||

  -1==prepareStatement(db, basecompoundref_insert) ||

  -1==prepareStatement(db, derivedcompoundref_insert) ||

  -1==prepareStatement(db, memberdef_params_insert)||

  -1==prepareStatement(db, innernamespace_insert)

  )

  {

    return -1;

  }

  return 0;

}

static void beginTransaction(sqlite3 *db)

{

  char * sErrMsg = 0;

  sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);

}

static void endTransaction(sqlite3 *db)

{

  char * sErrMsg = 0;

  sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);

}

static void pragmaTuning(sqlite3 *db)

{

  char * sErrMsg = 0;

  sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);

  sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);

  sqlite3_exec(db, "PRAGMA temp_store = MEMORY;", NULL, NULL, &sErrMsg);

}

static int initializeSchema(sqlite3* db)

{

  int rc;

  sqlite3_stmt *stmt = 0;

  msg("Initializing DB schema...\n");

  for (unsigned int k = 0; k < sizeof(schema_queries) / sizeof(schema_queries[0]); k++)

  {

    const char *q = schema_queries[k][1];

    char *errmsg;

    rc = sqlite3_exec(db, q, NULL, NULL, &errmsg);

    if (rc != SQLITE_OK)

    {

      msg("failed to execute query: %s\n\t%s\n", q, errmsg);

      return -1;

    }

  }

  return 0;

}

////////////////////////////////////////////

static void writeInnerClasses(const ClassSDict *cl)

{

  if (!cl) return;

  ClassSDict::Iterator cli(*cl);

  ClassDef *cd;

  for (cli.toFirst();(cd=cli.current());++cli)

  {

    if (!cd->isHidden() && cd->name().find('@')==-1) // skip anonymous scopes

    {

      int refid = insertRefid(cd->getOutputFileBase());

      bindIntParameter(innerclass_insert,":refid", refid);

      bindIntParameter(innerclass_insert,":prot",cd->protection());

      bindTextParameter(innerclass_insert,":name",cd->name());

      step(innerclass_insert);

    }

  }

}

static void writeInnerNamespaces(const NamespaceSDict *nl)

{

  if (nl)

  {

    NamespaceSDict::Iterator nli(*nl);

    NamespaceDef *nd;

    for (nli.toFirst();(nd=nli.current());++nli)

    {

      if (!nd->isHidden() && nd->name().find('@')==-1) // skip anonymouse scopes

      {

        int refid = insertRefid(nd->getOutputFileBase());

        bindIntParameter(innernamespace_insert,":refid",refid);

        bindTextParameter(innernamespace_insert,":name",nd->name(),FALSE);

        step(innernamespace_insert);

      }

    }

  }

}

static void writeTemplateArgumentList(const ArgumentList * al,

                                      const Definition * scope,

                                      const FileDef * fileScope)

{

  if (al)

  {

    ArgumentListIterator ali(*al);

    Argument *a;

    for (ali.toFirst();(a=ali.current());++ali)

    {

      if (!a->type.isEmpty())

      {

        #warning linkifyText(TextGeneratorXMLImpl(t),scope,fileScope,0,a->type);

        bindTextParameter(params_select,":type",a->type);

        bindTextParameter(params_insert,":type",a->type);

      }

      if (!a->name.isEmpty())

      {

        bindTextParameter(params_select,":declname",a->name);

        bindTextParameter(params_insert,":declname",a->name);

        bindTextParameter(params_select,":defname",a->name);

        bindTextParameter(params_insert,":defname",a->name);

      }

      if (!a->defval.isEmpty())

      {

        #warning linkifyText(TextGeneratorXMLImpl(t),scope,fileScope,0,a->defval);

        bindTextParameter(params_select,":defval",a->defval);

        bindTextParameter(params_insert,":defval",a->defval);

      }

      if (!step(params_select,TRUE,TRUE))

        step(params_insert);

    }

  }

}

static void writeMemberTemplateLists(const MemberDef *md)

{

  ArgumentList *templMd = md->templateArguments();

  if (templMd) // function template prefix

  {

    writeTemplateArgumentList(templMd,md->getClassDef(),md->getFileDef());

  }

}

static void writeTemplateList(const ClassDef *cd)

{

  writeTemplateArgumentList(cd->templateArguments(),cd,0);

}

////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

static void generateSqlite3ForMember(const MemberDef *md, const Definition *def)

{

  // + declaration/definition arg lists

  // + reimplements