Contributors:

Philippe Pepiot <phil@philpep.org>

Will Andrews <will@FreeBSD.org>

Marin Atanasov Nikolov <dnaeon@gmail.com>

# This could be handy for archiving the generated documentation or

# if some version control system is used.

# Using the PROJECT_BRIEF tag one can provide an optional one line description for a project that appears at the top of each page and should give viewer a quick idea about the purpose of the project. Keep the description short.

* [How can I use pkgng with portmaster?](#15)

* [How can I use pkgng with portupgrade?](#16)

* [pkgng does not work it says: /usr/local/sbin/pkg: Undefined symbol "pkg_event_register"](#17)

<a name="0"></a>

### Q: How can I start using pkgng?

Install ports-mgmt/pkg:

        # echo "WITH_PKGNG=yes" >> /etc/make.conf

Now register all packages you have in the pkgng database:

Here is how to do that:

<a name="11"></a>

### Q: How to start working with multi-repos in pkgng?

<a name="17"></a>

### Q: pkgng does not work it says: /usr/local/sbin/pkg: Undefined symbol "pkg_event_register"

`pkg add` can install a package archive from the local disk, or from a

remote FTP/HTTP server.

and download and install the package if it exists. The dependencies will be

downloaded and installed first.

This is possible because we have the dependency information in the

`pkg add` will check if the user attempts to install a package built for another

arch or release.

pkgng beta1 is now in the ports tree. To get it:

	$ echo "WITH_PKGNG=yes" >> /etc/make.conf

<a name="usageintro"></a>

or set _PACKAGESITE_ in the *pkg.conf(5)* configuration file.

In order to work with a single remote package repository, you would define _PACKAGESITE_ to

	TCSH users:

	# export PACKAGESITE=http://example.org/pkgng-repo/

	# pkg update

we are using only a single remote repository, which is defined by the _PACKAGESITE_ option.

In order to be able to work with multiple remote repositories and instead of changing

To do this, simply enable multi-repos in *pkg.conf(5)* like this:

The next thing is to define your remote repositories in the *pkg.conf(5)* file.

It is important that you always define a *default* repository - this is the repository that is being

used when no remote repositories are specified via the `-r <repo>` flag.

	# pkg update

- search:

	  to the users.

- info: 

- upgrade:

- update:

# include <io.h>

#define isatty(h) _isatty(h)

#define access(f,m) _access((f),(m))

#else

/* Make sure isatty() has a prototype.

*/

  int statsOn;           /* True to display memory stats before each finalize */

  int cnt;               /* Number of records displayed so far */

  FILE *out;             /* Write results here */

  int nErr;              /* Number of errors seen */

  int mode;              /* An output mode setting */

  int writableSchema;    /* True if PRAGMA writable_schema=ON */

  int i;

  char *zBlob = (char *)pBlob;

  fprintf(out,"X'");

  fprintf(out,"'");

}

    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);

    fprintf(pArg->out, "Page cache misses:                   %d\n", iCur); 

    iHiwtr = iCur = -1;

    sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);

    fprintf(pArg->out, "Schema Heap Usage:                   %d bytes\n", iCur); 

    iHiwtr = iCur = -1;

    char *zTableInfo = 0;

    char *zTmp = 0;

    int nRow = 0;

    zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);

    zTableInfo = appendText(zTableInfo, zTable, '"');

    }

    zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);

    if( zTmp ){

      zSelect = appendText(zSelect, zTmp, '\'');

    }

    zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);

    rc = sqlite3_step(pTableInfo);

      zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);

      run_table_dump_query(p, zSelect, 0);

    }

  }

  return 0;

}

    }

    zQ2 = malloc( len+100 );

    if( zQ2==0 ) return rc;

    rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);

    if( rc ){

      fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);

  "                         If TABLE specified, only list tables matching\n"

  "                         LIKE pattern TABLE.\n"

  ".timeout MS            Try opening locked tables for MS milliseconds\n"

  ".vfsname ?AUX?         Print the name of the VFS stack\n"

  ".width NUM1 NUM2 ...   Set column widths for \"column\" mode\n"

;

}

/*

** If an input line begins with "." then invoke this routine to

** process that line.

**

    bail_on_error = booleanValue(azArg[1]);

  }else

  if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){

    struct callback_data data;

    char *zErrMsg = 0;

  if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=2 ){

    const char *zFile = azArg[1];

  }else

  if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){

  }else

  if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){

    }

    }else{

      if( p->out==0 ){

        p->out = stdout;

        rc = 1;

      } else {

      }

    }

  }else

        zShellStatic = azArg[1];

        rc = sqlite3_exec(p->db,

          "SELECT sql FROM "

          "     FROM sqlite_master UNION ALL"

          "WHERE lower(tbl_name) LIKE shellstatic()"

          "  AND type!='meta' AND sql NOTNULL "

          callback, &data, &zErrMsg);

        zShellStatic = 0;

      }

    }else{

      rc = sqlite3_exec(p->db,

         "SELECT sql FROM "

         "     FROM sqlite_master UNION ALL"

         "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"

         callback, &data, &zErrMsg

      );

    }

  }else

  if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){

    char **azResult;

    open_db(p);

    }

    }else{

      int len, maxlen = 0;

      int i, j;

      int nPrintCol, nPrintRow;

        len = strlen30(azResult[i]);

        if( len>maxlen ) maxlen = len;

      }

      if( nPrintCol<1 ) nPrintCol = 1;

      nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;

      for(i=0; i<nPrintRow; i++){

          printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");

        }

        printf("\n");

      }

    }

  }else

  if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){

    enableTimer = booleanValue(azArg[1]);

  }else

  if( c=='v' && strncmp(azArg[0], "version", n)==0 ){

    printf("SQLite %s %s\n" /*extra-version-info*/,

        sqlite3_libversion(), sqlite3_sourceid());

    free(zLine);

    zLine = one_input_line(zSql, in);

    if( zLine==0 ){

    }

    if( seenInterrupt ){

      if( in!=0 ) break;

/*

** Return a pathname which is the user's home directory.  A

*/

static char *find_home_dir(void){

#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)

  struct passwd *pwent;

#if defined(_WIN32_WCE)

  /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()

   */

#else

#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)

  const char *sqliterc = sqliterc_override;

  char *zBuf = 0;

  FILE *in = NULL;

  int rc = 0;

  if (sqliterc == NULL) {

#endif

      return 1;

    }

  }

  in = fopen(sqliterc,"rb");

  if( in ){

    rc = process_input(p,in);

    fclose(in);

  }

  return rc;

}

        write_history(zHistory);

        free(zHistory);

      }

    }else{

      rc = process_input(&data, stdin);

    }

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

** This file is an amalgamation of many separate C source files from SQLite

** single large file, the entire code can be compiled as a single translation

** unit.  This allows many compilers to do optimizations that would not be

** possible if the files were compiled separately.  Performance improvements

#endif

/*

** feature.

*/

#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 

# define NDEBUG 1

#endif

/*

** The testcase() macro is used to aid in coverage testing.  When 

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

** [sqlite_version()] and [sqlite_source_id()].

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))

#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))

#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))

#define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))

#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))

#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))

#define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */

#define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */

#define SQLITE_OPEN_URI              0x00000040  /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */

#define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */

#define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */

**

** <li>[[SQLITE_FCNTL_PERSIST_WAL]]

** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the

** write ahead log and shared memory files used for transaction control

** are automatically deleted when the latest connection to the database

** closes.  Setting persistent WAL mode causes those files to persist after

** [SQLITE_USE_URI] symbol defined.

**

** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]]

** <dd> These options are obsolete and should not be used by new code.

** They are retained for backwards compatibility but are now no-ops.

** </dl>

** implementation of these routines to be omitted.  That capability

** is no longer provided.  Only built-in memory allocators can be used.

**

** the system malloc() and free() directly when converting

** filenames between the UTF-8 encoding used by SQLite

** and whatever filename encoding is used by the particular Windows

** [SQLITE_IOERR] rather than [SQLITE_NOMEM].

**

** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]

**     present, then the VFS specified by the option takes precedence over

**     the value passed as the fourth parameter to sqlite3_open_v2().

**

**     ^If "ro" is specified, then the database is opened for read-only 

**     access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the 

**     third argument to sqlite3_prepare_v2(). ^If the mode option is set to 

**     "rw", then the database is opened for read-write (but not create) 

**     access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had 

**     been set. ^Value "rwc" is equivalent to setting both 

**

**   <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or

**     "private". ^Setting it to "shared" is equivalent to setting the

SQLITE_API char *sqlite3_temp_directory;

/*

** CAPI3REF: Test For Auto-Commit Mode

** KEYWORDS: {autocommit mode}

**

/*

** CAPI3REF: Enable Or Disable Shared Pager Cache

**

** ^(This routine enables or disables the sharing of the database cache

** and schema data structures between [database connection | connections]

** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS 

** is always 0.

** </dd>

** </dl>

*/

#define SQLITE_DBSTATUS_LOOKASIDE_USED       0

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL  6

#define SQLITE_DBSTATUS_CACHE_HIT            7

#define SQLITE_DBSTATUS_CACHE_MISS           8

/*

SQLITE_API int sqlite3_rtree_geometry_callback(

  sqlite3 *db,

  const char *zGeom,

  void *pContext

);

SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);

SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*);

SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*);

SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*);

SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*);

SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*);

# endif

#endif

#if SQLITE_OS_WIN

# include <windows.h>

# if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY)

#  include <os2safe.h> /* has to be included before os2.h for linking to work */

# endif

# define INCL_DOSSEMAPHORES

# include <os2.h>

# include <uconv.h>

#endif

/*

# define SQLITE_OS_WINCE 0

#endif

/* If the SET_FULLSYNC macro is not defined above, then make it

** a no-op

*/

};

/*

*/

#define SQLITE_FUNC_LIKE     0x01 /* Candidate for the LIKE optimization */

#define SQLITE_FUNC_CASE     0x02 /* Case-sensitive LIKE-type function */

#define SQLITE_FUNC_EPHEM    0x04 /* Ephemeral.  Delete with VDBE */

#define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */

/*

** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are

**     parameter.

*/

#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \

   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}

#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \

  {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \

  FKey *pFKey;         /* Linked list of all foreign keys in this table */

  char *zColAff;       /* String defining the affinity of each column */

#ifndef SQLITE_OMIT_CHECK

#endif

#ifndef SQLITE_OMIT_ALTERTABLE

  int addColOffset;    /* Offset in CREATE TABLE stmt to add a new column */

  i16 iRightJoinTable;   /* If EP_FromJoin, the right table of the join */

  u8 flags2;             /* Second set of flags.  EP2_... */

  u8 op2;                /* If a TK_REGISTER, the original value of Expr.op */

  AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */

  Table *pTab;           /* Table for TK_COLUMN expressions. */

#if SQLITE_MAX_EXPR_DEPTH>0

#define EP_FixedDest  0x0200  /* Result needed in a specific register */

#define EP_IntValue   0x0400  /* Integer value contained in u.iValue */

#define EP_xIsSelect  0x0800  /* x.pSelect is valid (otherwise x.pList is) */

#define EP_Reduced    0x2000  /* Expr struct is EXPR_REDUCEDSIZE bytes only */

#define EP_TokenOnly  0x4000  /* Expr struct is EXPR_TOKENONLYSIZE bytes only */

#define EP_Static     0x8000  /* Held in memory not obtained from malloc() */

  Parse *pParse;       /* The parser */

  SrcList *pSrcList;   /* One or more tables used to resolve names */

  ExprList *pEList;    /* Optional list of named expressions */

  AggInfo *pAggInfo;   /* Information about aggregates at this level */

  NameContext *pNext;  /* Next outer name context.  NULL for outermost */

};

/*

** An instance of the following structure contains all information

** needed to generate code for a single SELECT statement.

**

  int regRowid;        /* Register holding rowid of CREATE TABLE entry */

  int regRoot;         /* Register holding root page number for new objects */

  int nMaxArg;         /* Max args passed to user function by sub-program */

#ifndef SQLITE_OMIT_SHARED_CACHE

  int nTableLock;        /* Number of locks in aTableLock */

  TableLock *aTableLock; /* Required table locks for shared-cache mode */

};

/*

*/

#define OPFLAG_NCHANGE       0x01    /* Set to update db->nChange */

#define OPFLAG_LASTROWID     0x02    /* Set to update db->lastRowid */

#define OPFLAG_APPEND        0x08    /* This is likely to be an append */

#define OPFLAG_USESEEKRESULT 0x10    /* Try to avoid a seek in BtreeInsert() */

#define OPFLAG_CLEARCACHE    0x20    /* Clear pseudo-table cache in OP_Column */

/*

 * Each trigger present in the database schema is stored as an instance of

  union {                                   /* Extra data for callback */

    NameContext *pNC;                          /* Naming context */

    int i;                                     /* Integer value */

  } u;

};

SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**);

SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);

SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);

SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);

SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);

SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*);

SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);

SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*, SrcList*, Expr*, ExprList**,ExprList*,u16);

SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*);

SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);

SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);

SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, int, int, int);

SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*);

SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int);

SQLITE_PRIVATE void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);

SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3*);

SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void);

SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void);

#  define sqlite3GetVTable(X,Y)  ((VTable*)0)

#else

SQLITE_PRIVATE    void sqlite3VtabClear(sqlite3 *db, Table*);

SQLITE_PRIVATE    int sqlite3VtabSync(sqlite3 *db, char **);

SQLITE_PRIVATE    int sqlite3VtabRollback(sqlite3 *db);

SQLITE_PRIVATE    int sqlite3VtabCommit(sqlite3 *db);

#ifdef SQLITE_COVERAGE_TEST

  "COVERAGE_TEST",

#endif

#ifdef SQLITE_DEBUG

  "DEBUG",

#endif

    ** to zero.

    */

    case SQLITE_DBSTATUS_CACHE_HIT:

      int i;

      int nRet = 0;

      assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );

      for(i=0; i<db->nDb; i++){

        if( db->aDb[i].pBt ){

** this out as well.

*/

#if 0

# define mutexIsNT()  (1)

#else

  static int mutexIsNT(void){

*/

static long winMutex_lock = 0;

static int winMutexInit(void){ 

  /* The first to increment to 1 does actual initialization */

  if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){

    int i;

    for(i=0; i<ArraySize(winMutex_staticMutexes); i++){

      InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);

    }

    winMutex_isInit = 1;

  }else{

    /* Someone else is in the process of initing the static mutexes */

    while( !winMutex_isInit ){

    }

  }

  return SQLITE_OK; 

#ifdef SQLITE_DEBUG

        p->id = iType;

#endif

        InitializeCriticalSection(&p->mutex);

      }

      break;

    }

    }

    if( isLookaside(db, p) ){

      LookasideSlot *pBuf = (LookasideSlot*)p;

      pBuf->pNext = db->lookaside.pFree;

      db->lookaside.pFree = pBuf;

      db->lookaside.nOut--;

#endif

/*

#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS

# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755

#endif

#if OS_VXWORKS

  struct vxworksFileId *pId;          /* Unique file ID */

#endif

  /* The next group of variables are used to track whether or not the

  ** transaction counter in bytes 24-27 of database files are updated

  ** whenever any part of the database changes.  An assertion fault will

#define UNIXFILE_DELETE      0x20     /* Delete on close */

#define UNIXFILE_URI         0x40     /* Filename might have query parameters */

#define UNIXFILE_NOLOCK      0x80     /* Do no file locking */

/*

** Include code that is common to all os_*.c files

  return open(zFile, flags, mode);

}

/* Forward reference */

static int openDirectory(const char*, int*);

  { "rmdir",        (sqlite3_syscall_ptr)rmdir,           0 },

#define osRmdir     ((int(*)(const char*))aSyscall[19].pCurrent)

#define osFchown    ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)

  { "umask",        (sqlite3_syscall_ptr)umask,           0 },

/*

** Invoke open().  Do so multiple times, until it either succeeds or

**

** If the file creation mode "m" is 0 then set it to the default for

** SQLite.  The default is SQLITE_DEFAULT_FILE_PERMISSIONS (normally

** recover the hot journals.

*/

static int robust_open(const char *z, int f, mode_t m){

  mode_t m2;

  mode_t origM = 0;

  if( m==0 ){

    m2 = m;

    origM = osUmask(0);

  }

  if( m ){

    osUmask(origM);

  }

}

/*

  }

  /* Set up the transaction-counter change checking flags when

  ** transitioning from a SHARED to a RESERVED lock.  The change

  ** from SHARED to RESERVED marks the beginning of a normal

  if( pFile->eFileLock>SHARED_LOCK ){

    assert( pInode->eFileLock==pFile->eFileLock );

    /* When reducing a lock such that other processes can start

    ** reading the database file again, make sure that the

    ** transaction counter was updated if any part of the database

    SimulateIOError( h=(-1) )

    SimulateIOErrorBenign(0);

    /* When reducing a lock such that other processes can start

    ** reading the database file again, make sure that the

    ** transaction counter was updated if any part of the database

  );

#endif

  /* If we are doing a normal write to a database file (as opposed to

  ** doing a hot-journal rollback or a write to some file other than a

  ** normal database file) then record the fact that the database

    zDirname[ii] = '\0';

    fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);

    if( fd>=0 ){

      OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));

    }

  }

  ** actual file size after the operation may be larger than the requested

  ** size).

  */

    nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;

  }

    pFile->lastErrno = errno;

    return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);

  }else{

    /* If we are doing a normal write to a database file (as opposed to

    ** doing a hot-journal rollback or a write to some file other than a

    ** normal database file) and we truncate the file to zero length,

      *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);

      return SQLITE_OK;

    }

    /* The pager calls this method to signal that it has done

    ** a rollback and that the database is therefore unchanged and

    ** it hence it is OK for the transaction change counter to be

      /* If this process is running as root, make sure that the SHM file

      ** is owned by the same user that owns the original database.  Otherwise,

      */

      /* Check to see if another process is holding the dead-man switch.

      ** If not, truncate the file to zero length. 

    /* If this process is running as root and if creating a new rollback

    ** journal or WAL file, set the ownership of the journal or WAL to be

    */

    if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){

    }

  }

  assert( fd>=0 );

  }

#endif

  noLock = eType!=SQLITE_OPEN_MAIN_DB;

/************** Continuing where we left off in os_win.c *********************/

/*

** Some Microsoft compilers lack this definition.

*/

#ifndef INVALID_FILE_ATTRIBUTES

# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) 

#endif

/* Forward references */

typedef struct winShm winShm;           /* A connection to shared-memory */

typedef struct winShmNode winShmNode;   /* A region of shared-memory */

#define WINFILE_PSOW            0x10   /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

/*

 * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the

 * various Win32 API heap functions instead of our own.

 */

#ifdef SQLITE_WIN32_MALLOC

/*

 * The initial size of the Win32-specific heap.  This value may be zero.

 */

static int sqlite3_os_type = 0;

#endif

#  define SQLITE_WIN32_HAS_ANSI

#endif

#  define SQLITE_WIN32_HAS_WIDE

#endif

#  define SYSCALL sqlite3_syscall_ptr

#endif

/*

 */

#  define osAreFileApisANSI()       1

#endif

static struct win_syscall {

  const char *zName;            /* Name of the sytem call */

  sqlite3_syscall_ptr pCurrent; /* Current value of the system call */

  sqlite3_syscall_ptr pDefault; /* Default value */

} aSyscall[] = {

  { "AreFileApisANSI",         (SYSCALL)AreFileApisANSI,         0 },

#else

  { "AreFileApisANSI",         (SYSCALL)0,                       0 },

#endif

#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)

  { "CharLowerW",              (SYSCALL)CharLowerW,              0 },

#else

#define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \

        LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent)

  { "CreateFileW",             (SYSCALL)CreateFileW,             0 },

#else

  { "CreateFileW",             (SYSCALL)0,                       0 },

#define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \

        LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)

  { "CreateFileMappingW",      (SYSCALL)CreateFileMappingW,      0 },

#else

  { "CreateFileMappingW",      (SYSCALL)0,                       0 },

#endif

#define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \

  { "CreateMutexW",            (SYSCALL)CreateMutexW,            0 },

#else

  { "CreateMutexW",            (SYSCALL)0,                       0 },

#endif

#define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \

#if defined(SQLITE_WIN32_HAS_ANSI)

  { "DeleteFileA",             (SYSCALL)DeleteFileA,             0 },