Import SQLite 3.8.7.4.

third_party/sqlite/src/src/test_intarray.c

 /*
 ** 2009 November 10
 **
 ** 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 19 matching lines @@
 struct sqlite3_intarray {
   int n;                    /* Number of elements in the array */
   sqlite3_int64 *a;         /* Contents of the array */
   void (*xFree)(void*);     /* Function used to free a[] */
 };
 
 /* Objects used internally by the virtual table implementation */
 typedef struct intarray_vtab intarray_vtab;
 typedef struct intarray_cursor intarray_cursor;
 
-/* A intarray table object */
+/* An intarray table object */
 struct intarray_vtab {
   sqlite3_vtab base;            /* Base class */
   sqlite3_intarray *pContent;   /* Content of the integer array */
 };
 
-/* A intarray cursor object */
+/* An intarray cursor object */
 struct intarray_cursor {
   sqlite3_vtab_cursor base;    /* Base class */
   int i;                       /* Current cursor position */
 };
 
 /*
 ** None of this works unless we have virtual tables.
 */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 
@@ skipping 152 matching lines @@
 ** Invoke this routine to create a specific instance of an intarray object.
 ** The new intarray object is returned by the 3rd parameter.
 **
 ** Each intarray object corresponds to a virtual table in the TEMP table
 ** with a name of zName.
 **
 ** Destroy the intarray object by dropping the virtual table.  If not done
 ** explicitly by the application, the virtual table will be dropped implicitly
 ** by the system when the database connection is closed.
 */
-int sqlite3_intarray_create(
+SQLITE_API int sqlite3_intarray_create(
   sqlite3 *db,
   const char *zName,
   sqlite3_intarray **ppReturn
 ){
   int rc = SQLITE_OK;
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   sqlite3_intarray *p;
 
   *ppReturn = p = sqlite3_malloc( sizeof(*p) );
   if( p==0 ){
@@ skipping 13 matching lines @@
   return rc;
 }
 
 /*
 ** Bind a new array array of integers to a specific intarray object.
 **
 ** The array of integers bound must be unchanged for the duration of
 ** any query against the corresponding virtual table.  If the integer
 ** array does change or is deallocated undefined behavior will result.
 */
-int sqlite3_intarray_bind(
+SQLITE_API int sqlite3_intarray_bind(
   sqlite3_intarray *pIntArray,   /* The intarray object to bind to */
   int nElements,                 /* Number of elements in the intarray */
   sqlite3_int64 *aElements,      /* Content of the intarray */
   void (*xFree)(void*)           /* How to dispose of the intarray when done */
 ){
   if( pIntArray->xFree ){
     pIntArray->xFree(pIntArray->a);
   }
   pIntArray->n = nElements;
   pIntArray->a = aElements;
   pIntArray->xFree = xFree;
   return SQLITE_OK;
 }
 
 
 /*****************************************************************************
 ** Everything below is interface for testing this module.
 */
 #ifdef SQLITE_TEST
 #include <tcl.h>
 
 /*
 ** Routines to encode and decode pointers
 */
 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
 extern void *sqlite3TestTextToPtr(const char*);
 extern int sqlite3TestMakePointerStr(Tcl_Interp*, char *zPtr, void*);
-extern const char *sqlite3TestErrorName(int);
+extern const char *sqlite3ErrName(int);
 
 /*
 **    sqlite3_intarray_create  DB  NAME
 **
 ** Invoke the sqlite3_intarray_create interface.  A string that becomes
 ** the first parameter to sqlite3_intarray_bind.
 */
 static int test_intarray_create(
   ClientData clientData, /* Not used */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
@@ skipping 10 matching lines @@
     Tcl_WrongNumArgs(interp, 1, objv, "DB");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   zName = Tcl_GetString(objv[2]);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   rc = sqlite3_intarray_create(db, zName, &pArray);
 #endif
   if( rc!=SQLITE_OK ){
     assert( pArray==0 );
-    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), (char*)0);
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), (char*)0);
     return TCL_ERROR;
   }
   sqlite3TestMakePointerStr(interp, zPtr, pArray);
   Tcl_AppendResult(interp, zPtr, (char*)0);
   return TCL_OK;
 }
 
 /*
 **    sqlite3_intarray_bind  INTARRAY  ?VALUE ...?
 **
@@ skipping 16 matching lines @@
   }
   pArray = (sqlite3_intarray*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   n = objc - 2;
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   a = sqlite3_malloc( sizeof(a[0])*n );
   if( a==0 ){
     Tcl_AppendResult(interp, "SQLITE_NOMEM", (char*)0);
     return TCL_ERROR;
   }
   for(i=0; i<n; i++){
-    a[i] = 0;
-    Tcl_GetWideIntFromObj(0, objv[i+2], &a[i]);
+    Tcl_WideInt x = 0;
+    Tcl_GetWideIntFromObj(0, objv[i+2], &x);
+    a[i] = x;
   }
   rc = sqlite3_intarray_bind(pArray, n, a, sqlite3_free);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), (char*)0);
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), (char*)0);
     return TCL_ERROR;
   }
 #endif
   return TCL_OK;
 }
 
 /*
 ** Register commands with the TCL interpreter.
 */
 int Sqlitetestintarray_Init(Tcl_Interp *interp){
   static struct {
      char *zName;
      Tcl_ObjCmdProc *xProc;
      void *clientData;
   } aObjCmd[] = {
      { "sqlite3_intarray_create", test_intarray_create, 0 },
      { "sqlite3_intarray_bind", test_intarray_bind, 0 },
   };
   int i;
   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
         aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
   }
   return TCL_OK;
 }
 
 #endif /* SQLITE_TEST */