[sql] Import SQLite 3.17.0.

third_party/sqlite/src/src/test_quota.c

 /*
 ** 2010 September 31
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
@@ skipping 93 matching lines @@
   char *zFilename;                /* Name of this file */
   quotaGroup *pGroup;             /* Quota group to which this file belongs */
   sqlite3_int64 iSize;            /* Current size of this file */
   int nRef;                       /* Number of times this file is open */
   int deleteOnClose;              /* True to delete this file when it closes */
   quotaFile *pNext, **ppPrev;     /* Linked list of files in the same group */
 };
 
 /*
 ** An instance of the following object represents each open connection
-** to a file that participates in quota tracking.  This object is a 
+** to a file that participates in quota tracking.  This object is a
 ** subclass of sqlite3_file.  The sqlite3_file object for the underlying
 ** VFS is appended to this structure.
 */
 struct quotaConn {
   sqlite3_file base;              /* Base class - must be first */
   quotaFile *pFile;               /* The underlying file */
   /* The underlying VFS sqlite3_file is appended to this object */
 };
 
 /*
@@ skipping 22 matching lines @@
   ** during operation.  It is only modified at start-time and thus does not
   ** require a mutex.
   */
   sqlite3_vfs *pOrigVfs;
 
   /* The sThisVfs is the VFS structure used by this shim.  It is initialized
   ** at start-time and thus does not require a mutex
   */
   sqlite3_vfs sThisVfs;
 
-  /* The sIoMethods defines the methods used by sqlite3_file objects 
+  /* The sIoMethods defines the methods used by sqlite3_file objects
   ** associated with this shim.  It is initialized at start-time and does
   ** not require a mutex.
   **
-  ** When the underlying VFS is called to open a file, it might return 
+  ** When the underlying VFS is called to open a file, it might return
   ** either a version 1 or a version 2 sqlite3_file object.  This shim
   ** has to create a wrapper sqlite3_file of the same version.  Hence
   ** there are two I/O method structures, one for version 1 and the other
   ** for version 2.
   */
   sqlite3_io_methods sIoMethodsV1;
   sqlite3_io_methods sIoMethodsV2;
 
   /* True when this shim as been initialized.
   */
@@ skipping 11 matching lines @@
 } gQuota;
 
 /************************* Utility Routines *********************************/
 /*
 ** Acquire and release the mutex used to serialize access to the
 ** list of quotaGroups.
 */
 static void quotaEnter(void){ sqlite3_mutex_enter(gQuota.pMutex); }
 static void quotaLeave(void){ sqlite3_mutex_leave(gQuota.pMutex); }
 
-/* Count the number of open files in a quotaGroup 
+/* Count the number of open files in a quotaGroup
 */
 static int quotaGroupOpenFileCount(quotaGroup *pGroup){
   int N = 0;
   quotaFile *pFile = pGroup->pFiles;
   while( pFile ){
     if( pFile->nRef ) N++;
     pFile = pFile->pNext;
   }
   return N;
 }
@@ skipping 188 matching lines @@
   codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
   nMbcs = WideCharToMultiByte(codepage, 0, zTmpWide, nWide, 0, 0, 0, 0);
   zMbcs = nMbcs ? (char*)sqlite3_malloc( nMbcs+1 ) : 0;
   if( zMbcs ){
     WideCharToMultiByte(codepage, 0, zTmpWide, nWide, zMbcs, nMbcs, 0, 0);
   }
   sqlite3_free(zTmpWide);
   return zMbcs;
 #else
   return (char*)zUtf8;  /* No-op on unix */
-#endif  
+#endif
 }
 
 /*
 ** Deallocate any memory allocated by quota_utf8_to_mbcs().
 */
 static void quota_mbcs_free(char *zOld){
 #if SQLITE_OS_WIN
   sqlite3_free(zOld);
 #else
   /* No-op on unix */
-#endif  
+#endif
 }
 
 /************************* VFS Method Wrappers *****************************/
 /*
 ** This is the xOpen method used for the "quota" VFS.
 **
 ** Most of the work is done by the underlying original VFS.  This method
 ** simply links the new file into the appropriate quota group if it is a
 ** file that needs to be tracked.
 */
 static int quotaOpen(
   sqlite3_vfs *pVfs,          /* The quota VFS */
   const char *zName,          /* Name of file to be opened */
   sqlite3_file *pConn,        /* Fill in this file descriptor */
   int flags,                  /* Flags to control the opening */
   int *pOutFlags              /* Flags showing results of opening */
 ){
-  int rc;                                    /* Result code */         
+  int rc;                                    /* Result code */
   quotaConn *pQuotaOpen;                     /* The new quota file descriptor */
   quotaFile *pFile;                          /* Corresponding quotaFile obj */
   quotaGroup *pGroup;                        /* The group file belongs to */
   sqlite3_file *pSubOpen;                    /* Real file descriptor */
   sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs;   /* Real VFS */
 
   /* If the file is not a main database file or a WAL, then use the
   ** normal xOpen method.
   */
   if( (flags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_WAL))==0 ){
@@ skipping 39 matching lines @@
 **
 ** If the file being deleted is part of the quota group, then reduce
 ** the size of the quota group accordingly.  And remove the file from
 ** the set of files in the quota group.
 */
 static int quotaDelete(
   sqlite3_vfs *pVfs,          /* The quota VFS */
   const char *zName,          /* Name of file to be deleted */
   int syncDir                 /* Do a directory sync after deleting */
 ){
-  int rc;                                    /* Result code */         
+  int rc;                                    /* Result code */
   quotaFile *pFile;                          /* Files in the quota */
   quotaGroup *pGroup;                        /* The group file belongs to */
   sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs;   /* Real VFS */
 
   /* Do the actual file delete */
   rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir);
 
   /* If the file just deleted is a member of a quota group, then remove
   ** it from that quota group.
   */
@@ skipping 72 matching lines @@
   quotaGroup *pGroup;
   quotaFile *pFile = p->pFile;
   sqlite3_int64 szNew;
 
   if( pFile->iSize<iEnd ){
     pGroup = pFile->pGroup;
     quotaEnter();
     szNew = pGroup->iSize - pFile->iSize + iEnd;
     if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
       if( pGroup->xCallback ){
-        pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew, 
+        pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew,
                           pGroup->pArg);
       }
       if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
         quotaLeave();
         return SQLITE_FULL;
       }
     }
     pGroup->iSize = szNew;
     pFile->iSize = iEnd;
     quotaLeave();
@@ skipping 136 matching lines @@
 */
 static int quotaShmUnmap(sqlite3_file *pConn, int deleteFlag){
   sqlite3_file *pSubOpen = quotaSubOpen(pConn);
   return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
 }
 
 /************************** Public Interfaces *****************************/
 /*
 ** Initialize the quota VFS shim.  Use the VFS named zOrigVfsName
 ** as the VFS that does the actual work.  Use the default if
-** zOrigVfsName==NULL.  
+** zOrigVfsName==NULL.
 **
 ** The quota VFS shim is named "quota".  It will become the default
 ** VFS if makeDefault is non-zero.
 **
 ** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once
 ** during start-up.
 */
 int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
   sqlite3_vfs *pOrigVfs;
   if( gQuota.isInitialized ) return SQLITE_MISUSE;
@@ skipping 149 matching lines @@
   if( fd==0 ){
     rc = SQLITE_NOMEM;
   }else{
     zFull = &((char *)fd)[gQuota.sThisVfs.szOsFile];
     rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename,
         gQuota.sThisVfs.mxPathname+1, zFull);
   }
 
   if( rc==SQLITE_OK ){
     zFull[strlen(zFull)+1] = '\0';
-    rc = quotaOpen(&gQuota.sThisVfs, zFull, fd, 
+    rc = quotaOpen(&gQuota.sThisVfs, zFull, fd,
                    SQLITE_OPEN_READONLY | SQLITE_OPEN_MAIN_DB, &outFlags);
     if( rc==SQLITE_OK ){
       fd->pMethods->xFileSize(fd, &iSize);
       fd->pMethods->xClose(fd);
     }else if( rc==SQLITE_CANTOPEN ){
       quotaGroup *pGroup;
       quotaFile *pFile;
       quotaEnter();
       pGroup = quotaGroupFind(zFull);
       if( pGroup ){
@@ skipping 87 matching lines @@
 
   iOfst = ftell(p->f);
   iEnd = iOfst + size*nmemb;
   pFile = p->pFile;
   if( pFile && pFile->iSize<iEnd ){
     quotaGroup *pGroup = pFile->pGroup;
     quotaEnter();
     szNew = pGroup->iSize - pFile->iSize + iEnd;
     if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
       if( pGroup->xCallback ){
-        pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew, 
+        pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew,
                           pGroup->pArg);
       }
       if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
         iEnd = pGroup->iLimit - pGroup->iSize + pFile->iSize;
         nmemb = (size_t)((iEnd - iOfst)/size);
         iEnd = iOfst + size*nmemb;
         szNew = pGroup->iSize - pFile->iSize + iEnd;
       }
     }
     pGroup->iSize = szNew;
@@ skipping 166 matching lines @@
 #endif
   return rc==0 ? buf.st_size : -1;
 }
 
 /*
 ** Return the size of the file, as it is known to the quota subsystem.
 */
 sqlite3_int64 sqlite3_quota_file_size(quota_FILE *p){
   return p->pFile ? p->pFile->iSize : -1;
 }
- 
+
 /*
 ** Determine the amount of data in bytes available for reading
 ** in the given file.
 */
 long sqlite3_quota_file_available(quota_FILE *p){
   FILE* f = p->f;
   long pos1, pos2;
   int rc;
   pos1 = ftell(f);
   if ( pos1 < 0 ) return -1;
@@ skipping 51 matching lines @@
           quotaRemoveFile(pFile);
           quotaGroupDeref(pGroup);
         }
       }
     }
   }
   quotaLeave();
   sqlite3_free(zFull);
   return rc;
 }
-  
+
 /***************************** Test Code ***********************************/
 #ifdef SQLITE_TEST
-#include <tcl.h>
+#if defined(INCLUDE_SQLITE_TCL_H)
+#  include "sqlite_tcl.h"
+#else
+#  include "tcl.h"
+#  ifndef SQLITE_TCLAPI
+#    define SQLITE_TCLAPI
+#  endif
+#endif
 
 /*
 ** Argument passed to a TCL quota-over-limit callback.
 */
 typedef struct TclQuotaCallback TclQuotaCallback;
 struct TclQuotaCallback {
   Tcl_Interp *interp;    /* Interpreter in which to run the script */
   Tcl_Obj *pScript;      /* Script to be run */
 };
 
@@ skipping 51 matching lines @@
   TclQuotaCallback *p = (TclQuotaCallback*)pObj;
   if( p ){
     Tcl_DecrRefCount(p->pScript);
     sqlite3_free((char *)p);
   }
 }
 
 /*
 ** tclcmd: sqlite3_quota_initialize NAME MAKEDEFAULT
 */
-static int test_quota_initialize(
+static int SQLITE_TCLAPI test_quota_initialize(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zName;              /* Name of new quota VFS */
   int makeDefault;                /* True to make the new VFS the default */
   int rc;                         /* Value returned by quota_initialize() */
 
   /* Process arguments */
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
     return TCL_ERROR;
   }
   zName = Tcl_GetString(objv[1]);
   if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
   if( zName[0]=='\0' ) zName = 0;
 
   /* Call sqlite3_quota_initialize() */
   rc = sqlite3_quota_initialize(zName, makeDefault);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
 
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_shutdown
 */
-static int test_quota_shutdown(
+static int SQLITE_TCLAPI test_quota_shutdown(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;                         /* Value returned by quota_shutdown() */
 
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
 
   /* Call sqlite3_quota_shutdown() */
   rc = sqlite3_quota_shutdown();
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
 
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_set PATTERN LIMIT SCRIPT
 */
-static int test_quota_set(
+static int SQLITE_TCLAPI test_quota_set(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zPattern;           /* File pattern to configure */
   Tcl_WideInt iLimit;             /* Initial quota in bytes */
   Tcl_Obj *pScript;               /* Tcl script to invoke to increase quota */
   int rc;                         /* Value returned by quota_set() */
   TclQuotaCallback *p;            /* Callback object */
@@ skipping 33 matching lines @@
   /* Invoke sqlite3_quota_set() */
   rc = sqlite3_quota_set(zPattern, iLimit, xCallback, (void*)p, xDestroy);
 
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_file FILENAME
 */
-static int test_quota_file(
+static int SQLITE_TCLAPI test_quota_file(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zFilename;          /* File pattern to configure */
   int rc;                         /* Value returned by quota_file() */
 
   /* Process arguments */
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
     return TCL_ERROR;
   }
   zFilename = Tcl_GetString(objv[1]);
 
   /* Invoke sqlite3_quota_file() */
   rc = sqlite3_quota_file(zFilename);
 
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
   return TCL_OK;
 }
 
 /*
 ** tclcmd:  sqlite3_quota_dump
 */
-static int test_quota_dump(
+static int SQLITE_TCLAPI test_quota_dump(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   Tcl_Obj *pResult;
   Tcl_Obj *pGroupTerm;
   Tcl_Obj *pFileTerm;
   quotaGroup *pGroup;
   quotaFile *pFile;
@@ skipping 27 matching lines @@
     Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
   }
   quotaLeave();
   Tcl_SetObjResult(interp, pResult);
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_fopen FILENAME MODE
 */
-static int test_quota_fopen(
+static int SQLITE_TCLAPI test_quota_fopen(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zFilename;          /* File pattern to configure */
   const char *zMode;              /* Mode string */
   quota_FILE *p;                  /* Open string object */
   char zReturn[50];               /* Name of pointer to return */
 
   /* Process arguments */
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "FILENAME MODE");
     return TCL_ERROR;
   }
   zFilename = Tcl_GetString(objv[1]);
   zMode = Tcl_GetString(objv[2]);
   p = sqlite3_quota_fopen(zFilename, zMode);
   sqlite3_snprintf(sizeof(zReturn), zReturn, "%p", p);
   Tcl_SetResult(interp, zReturn, TCL_VOLATILE);
   return TCL_OK;
 }
 
 /* Defined in test1.c */
 extern void *sqlite3TestTextToPtr(const char*);
 
 /*
 ** tclcmd: sqlite3_quota_fread HANDLE SIZE NELEM
 */
-static int test_quota_fread(
+static int SQLITE_TCLAPI test_quota_fread(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   char *zBuf;
   int sz;
   int nElem;
   size_t got;
@@ skipping 13 matching lines @@
   got = sqlite3_quota_fread(zBuf, sz, nElem, p);
   zBuf[got*sz] = 0;
   Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
   sqlite3_free(zBuf);
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_fwrite HANDLE SIZE NELEM CONTENT
 */
-static int test_quota_fwrite(
+static int SQLITE_TCLAPI test_quota_fwrite(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   char *zBuf;
   int sz;
   int nElem;
   size_t got;
 
   if( objc!=5 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE NELEM CONTENT");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   if( Tcl_GetIntFromObj(interp, objv[2], &sz) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[3], &nElem) ) return TCL_ERROR;
   zBuf = Tcl_GetString(objv[4]);
   got = sqlite3_quota_fwrite(zBuf, sz, nElem, p);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(got));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_fclose HANDLE
 */
-static int test_quota_fclose(
+static int SQLITE_TCLAPI test_quota_fclose(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   int rc;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   rc = sqlite3_quota_fclose(p);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_fflush HANDLE ?HARDSYNC?
 */
-static int test_quota_fflush(
+static int SQLITE_TCLAPI test_quota_fflush(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   int rc;
   int doSync = 0;
 
   if( objc!=2 && objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE ?HARDSYNC?");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   if( objc==3 ){
     if( Tcl_GetBooleanFromObj(interp, objv[2], &doSync) ) return TCL_ERROR;
   }
   rc = sqlite3_quota_fflush(p, doSync);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_fseek HANDLE OFFSET WHENCE
 */
-static int test_quota_fseek(
+static int SQLITE_TCLAPI test_quota_fseek(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   int ofst;
   const char *zWhence;
   int whence;
   int rc;
@@ skipping 17 matching lines @@
     return TCL_ERROR;
   }
   rc = sqlite3_quota_fseek(p, ofst, whence);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_rewind HANDLE
 */
-static int test_quota_rewind(
+static int SQLITE_TCLAPI test_quota_rewind(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   sqlite3_quota_rewind(p);
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_ftell HANDLE
 */
-static int test_quota_ftell(
+static int SQLITE_TCLAPI test_quota_ftell(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   sqlite3_int64 x;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   x = sqlite3_quota_ftell(p);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_ftruncate HANDLE SIZE
 */
-static int test_quota_ftruncate(
+static int SQLITE_TCLAPI test_quota_ftruncate(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   sqlite3_int64 x;
   Tcl_WideInt w;
   int rc;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   if( Tcl_GetWideIntFromObj(interp, objv[2], &w) ) return TCL_ERROR;
   x = (sqlite3_int64)w;
   rc = sqlite3_quota_ftruncate(p, x);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_file_size HANDLE
 */
-static int test_quota_file_size(
+static int SQLITE_TCLAPI test_quota_file_size(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   sqlite3_int64 x;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   x = sqlite3_quota_file_size(p);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_file_truesize HANDLE
 */
-static int test_quota_file_truesize(
+static int SQLITE_TCLAPI test_quota_file_truesize(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   sqlite3_int64 x;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   x = sqlite3_quota_file_truesize(p);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_file_mtime HANDLE
 */
-static int test_quota_file_mtime(
+static int SQLITE_TCLAPI test_quota_file_mtime(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   time_t t;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   t = 0;
   sqlite3_quota_file_mtime(p, &t);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(t));
   return TCL_OK;
 }
 
 
 /*
 ** tclcmd: sqlite3_quota_remove FILENAME
 */
-static int test_quota_remove(
+static int SQLITE_TCLAPI test_quota_remove(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zFilename;          /* File pattern to configure */
   int rc;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
     return TCL_ERROR;
   }
   zFilename = Tcl_GetString(objv[1]);
   rc = sqlite3_quota_remove(zFilename);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_glob PATTERN TEXT
 **
 ** Test the glob pattern matching.  Return 1 if TEXT matches PATTERN
 ** and return 0 if it does not.
 */
-static int test_quota_glob(
+static int SQLITE_TCLAPI test_quota_glob(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zPattern;          /* The glob pattern */
   const char *zText;             /* Text to compare agains the pattern */
   int rc;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "PATTERN TEXT");
     return TCL_ERROR;
   }
   zPattern = Tcl_GetString(objv[1]);
   zText = Tcl_GetString(objv[2]);
   rc = quotaStrglob(zPattern, zText);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_file_available HANDLE
 **
 ** Return the number of bytes from the current file point to the end of
 ** the file.
 */
-static int test_quota_file_available(
+static int SQLITE_TCLAPI test_quota_file_available(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   sqlite3_int64 x;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
   }
   p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   x = sqlite3_quota_file_available(p);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x));
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_quota_ferror HANDLE
 **
 ** Return true if the file handle is in the error state.
 */
-static int test_quota_ferror(
+static int SQLITE_TCLAPI test_quota_ferror(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   quota_FILE *p;
   int x;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
     return TCL_ERROR;
@@ skipping 38 matching lines @@
   };
   int i;
 
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
   }
 
   return TCL_OK;
 }
 #endif