rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/sqlite3/SqliteWrapper/mutex_c.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2007 August 14
+    **
+    ** 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.
+    **
+    *************************************************************************
+    ** This file contains the C functions that implement mutexes.
+    **
+    ** This file contains code that is common across all mutex implementations.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+
+#if (SQLITE_DEBUG) && !(SQLITE_MUTEX_OMIT)
+/*
+** For debugging purposes, record when the mutex subsystem is initialized
+** and uninitialized so that we can assert() if there is an attempt to
+** allocate a mutex while the system is uninitialized.
+*/
+static SQLITE_WSD int mutexIsInit = 0;
+#endif //* SQLITE_DEBUG */
+
+#if !SQLITE_MUTEX_OMIT
+/*
+** Initialize the mutex system.
+*/
+static int sqlite3MutexInit()
+{
+int rc = SQLITE_OK;
+if (  sqlite3GlobalConfig.bCoreMutex   )
+{
+if (  sqlite3GlobalConfig.mutex.xMutexAlloc != null )
+{
+/* If the xMutexAlloc method has not been set, then the user did not
+** install a mutex implementation via sqlite3_config() prior to
+** sqlite3_initialize() being called. This block copies pointers to
+** the default implementation into the sqlite3Config structure.
+**
+*/
+sqlite3_mutex_methods p = sqlite3DefaultMutex();
+sqlite3_mutex_methods pTo = sqlite3GlobalConfig.mutex;
+
+ memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
+      memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
+             sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
+      pTo->xMutexAlloc = pFrom->xMutexAlloc;
+}
+    rc =  sqlite3GlobalConfig.mutex.xMutexInit();
+}
+#if SQLITE_DEBUG
+  GLOBAL(int, mutexIsInit) = 1;
+#endif
+
+return rc;
+}
+
+/*
+** Shutdown the mutex system. This call frees resources allocated by
+** sqlite3MutexInit().
+*/
+static int sqlite3MutexEnd()
+{
+int rc = SQLITE_OK;
+if( sqlite3GlobalConfig.mutex.xMutexEnd ){
+rc = sqlite3GlobalConfig.mutex.xMutexEnd();
+}
+#if SQLITE_DEBUG
+  GLOBAL(int, mutexIsInit) = 0;
+#endif
+return rc;
+}
+
+/*
+** Retrieve a pointer to a static mutex or allocate a new dynamic one.
+*/
+static sqlite3_mutex sqlite3_mutex_alloc( int id )
+{
+#if !SQLITE_OMIT_AUTOINIT
+if ( sqlite3_initialize() != 0 ) return null;
+#endif
+return  sqlite3GlobalConfig.mutex.xMutexAlloc( id );
+}
+
+static sqlite3_mutex sqlite3MutexAlloc( int id )
+{
+if ( ! sqlite3GlobalConfig.bCoreMutex   )
+{
+return null;
+}
+assert( GLOBAL(int, mutexIsInit) );
+return  sqlite3GlobalConfig.mutex.xMutexAlloc( id );
+}
+
+/*
+** Free a dynamic mutex.
+*/
+static void sqlite3_mutex_free( ref sqlite3_mutex p )
+{
+if ( p != null )
+{
+sqlite3GlobalConfig.mutex.xMutexFree( p );
+}
+}
+
+/*
+** Obtain the mutex p. If some other thread already has the mutex, block
+** until it can be obtained.
+*/
+static void sqlite3_mutex_enter( sqlite3_mutex p )
+{
+if ( p != null )
+{
+sqlite3GlobalConfig.mutex.xMutexEnter( p );
+}
+}
+
+/*
+** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
+** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
+*/
+static int sqlite3_mutex_try( sqlite3_mutex p )
+{
+int rc = SQLITE_OK;
+if ( p != null )
+{
+return  sqlite3GlobalConfig.mutex.xMutexTry( p );
+}
+return rc;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was previously
+** entered by the same thread.  The behavior is undefined if the mutex
+** is not currently entered. If a NULL pointer is passed as an argument
+** this function is a no-op.
+*/
+static void sqlite3_mutex_leave( sqlite3_mutex p )
+{
+if ( p != null )
+{
+sqlite3GlobalConfig.mutex.xMutexLeave( p );
+}
+}
+
+#if !NDEBUG
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use inside Debug.Assert() statements.
+*/
+static bool sqlite3_mutex_held( sqlite3_mutex p )
+{
+return ( p == null ||  sqlite3GlobalConfig.mutex.xMutexHeld( p ) != 0 ) ;
+}
+static bool sqlite3_mutex_notheld( sqlite3_mutex p )
+{
+return ( p == null ||  sqlite3GlobalConfig.mutex.xMutexNotheld( p ) != 0 ) ;
+}
+#endif
+
+#endif //* SQLITE_MUTEX_OMIT */
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/mutex_h.cs

@@ -0,0 +1,91 @@
+#define SQLITE_OS_WIN
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2007 August 28
+    **
+    ** 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.
+    **
+    *************************************************************************
+    **
+    ** This file contains the common header for all mutex implementations.
+    ** The sqliteInt.h header #includes this file so that it is available
+    ** to all source files.  We break it out in an effort to keep the code
+    ** better organized.
+    **
+    ** NOTE:  source files should *not* #include this header file directly.
+    ** Source files should #include the sqliteInt.h file and let that file
+    ** include this one indirectly.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+
+
+    /*
+    ** Figure out what version of the code to use.  The choices are
+    **
+    **   SQLITE_MUTEX_OMIT         No mutex logic.  Not even stubs.  The
+    **                             mutexes implemention cannot be overridden
+    **                             at start-time.
+    **
+    **   SQLITE_MUTEX_NOOP         For single-threaded applications.  No
+    **                             mutual exclusion is provided.  But this
+    **                             implementation can be overridden at
+    **                             start-time.
+    **
+    **   SQLITE_MUTEX_PTHREADS     For multi-threaded applications on Unix.
+    **
+    **   SQLITE_MUTEX_W32          For multi-threaded applications on Win32.
+    **
+    **   SQLITE_MUTEX_OS2          For multi-threaded applications on OS/2.
+    */
+
+    //#if !SQLITE_THREADSAFE
+    //# define SQLITE_MUTEX_OMIT
+    //#endif
+    //#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP)
+    //#  if SQLITE_OS_UNIX
+    //#    define SQLITE_MUTEX_PTHREADS
+    //#  elif SQLITE_OS_WIN
+    //#    define SQLITE_MUTEX_W32
+    //#  elif SQLITE_OS_OS2
+    //#    define SQLITE_MUTEX_OS2
+    //#  else
+    //#    define SQLITE_MUTEX_NOOP
+    //#  endif
+    //#endif
+
+
+#if SQLITE_MUTEX_OMIT
+    /*
+** If this is a no-op implementation, implement everything as macros.
+*/
+    public class sqlite3_mutex { }
+    static sqlite3_mutex mutex = null;  //sqlite3_mutex sqlite3_mutex;
+    static sqlite3_mutex sqlite3MutexAlloc( int iType ) { return new sqlite3_mutex(); }//#define sqlite3MutexAlloc(X)      ((sqlite3_mutex*)8)
+    static sqlite3_mutex sqlite3_mutex_alloc( int iType ) { return new sqlite3_mutex(); }//#define sqlite3_mutex_alloc(X)    ((sqlite3_mutex*)8)
+    static void sqlite3_mutex_free( ref sqlite3_mutex m ) { }          //#define sqlite3_mutex_free(X)
+    static void sqlite3_mutex_enter( sqlite3_mutex m ) { }            //#define sqlite3_mutex_enter(X)
+    static int sqlite3_mutex_try( int iType ) { return SQLITE_OK; }   //#define sqlite3_mutex_try(X)      SQLITE_OK
+    static void sqlite3_mutex_leave( sqlite3_mutex m ) { }            //#define sqlite3_mutex_leave(X)
+    static bool sqlite3_mutex_held( sqlite3_mutex m ) { return true; }//#define sqlite3_mutex_held(X)     1
+    static bool sqlite3_mutex_notheld( sqlite3_mutex m ) { return true; }   //#define sqlite3_mutex_notheld(X)  1
+    static int sqlite3MutexInit() { return SQLITE_OK; }              //#define sqlite3MutexInit()        SQLITE_OK
+    static void sqlite3MutexEnd() { }                                //#define sqlite3MutexEnd()
+#endif //* defined(SQLITE_MUTEX_OMIT) */
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/mutex_noop_c.cs

@@ -0,0 +1,202 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2008 October 07
+    **
+    ** 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.
+    **
+    *************************************************************************
+    ** This file contains the C functions that implement mutexes.
+    **
+    ** This implementation in this file does not provide any mutual
+    ** exclusion and is thus suitable for use only in applications
+    ** that use SQLite in a single thread.  The routines defined
+    ** here are place-holders.  Applications can substitute working
+    ** mutex routines at start-time using the
+    **
+    **     sqlite3_config(SQLITE_CONFIG_MUTEX,...)
+    **
+    ** interface.
+    **
+    ** If compiled with SQLITE_DEBUG, then additional logic is inserted
+    ** that does error checking on mutexes to make sure they are being
+    ** called correctly.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+
+
+#if (SQLITE_MUTEX_NOOP) && !(SQLITE_DEBUG)
+/*
+** Stub routines for all mutex methods.
+**
+** This routines provide no mutual exclusion or error checking.
+*/
+static int noopMutexHeld(sqlite3_mutex *p){ return 1; }
+static int noopMutexNotheld(sqlite3_mutex *p){ return 1; }
+static int noopMutexInit(void){ return SQLITE_OK; }
+static int noopMutexEnd(void){ return SQLITE_OK; }
+static sqlite3_mutex *noopMutexAlloc(int id){ return (sqlite3_mutex*)8; }
+static void noopMutexFree(sqlite3_mutex *p){ return; }
+static void noopMutexEnter(sqlite3_mutex *p){ return; }
+static int noopMutexTry(sqlite3_mutex *p){ return SQLITE_OK; }
+static void noopMutexLeave(sqlite3_mutex *p){ return; }
+
+sqlite3_mutex_methods *sqlite3DefaultMutex(void){
+static sqlite3_mutex_methods sMutex = {
+noopMutexInit,
+noopMutexEnd,
+noopMutexAlloc,
+noopMutexFree,
+noopMutexEnter,
+noopMutexTry,
+noopMutexLeave,
+
+noopMutexHeld,
+noopMutexNotheld
+};
+
+return &sMutex;
+}
+#endif //* defined(SQLITE_MUTEX_NOOP) && !defined(SQLITE_DEBUG) */
+
+#if (SQLITE_MUTEX_NOOP) && (SQLITE_DEBUG)
+/*
+** In this implementation, error checking is provided for testing
+** and debugging purposes.  The mutexes still do not provide any
+** mutual exclusion.
+*/
+
+/*
+** The mutex object
+*/
+struct sqlite3_mutex {
+int id;     /* The mutex type */
+int cnt;    /* Number of entries without a matching leave */
+};
+
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use inside Debug.Assert() statements.
+*/
+static int debugMutexHeld(sqlite3_mutex *p){
+return p==0 || p->cnt>0;
+}
+static int debugMutexNotheld(sqlite3_mutex *p){
+return p==0 || p->cnt==0;
+}
+
+/*
+** Initialize and deinitialize the mutex subsystem.
+*/
+static int debugMutexInit(void){ return SQLITE_OK; }
+static int debugMutexEnd(void){ return SQLITE_OK; }
+
+/*
+** The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it.  If it returns NULL
+** that means that a mutex could not be allocated.
+*/
+static sqlite3_mutex *debugMutexAlloc(int id){
+static sqlite3_mutex aStatic[6];
+sqlite3_mutex *pNew = 0;
+switch( id ){
+case SQLITE_MUTEX_FAST:
+case SQLITE_MUTEX_RECURSIVE: {
+pNew = sqlite3Malloc(sizeof(*pNew));
+if( pNew ){
+pNew->id = id;
+pNew->cnt = 0;
+}
+break;
+}
+default: {
+Debug.Assert( id-2 >= 0 );
+assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
+pNew = &aStatic[id-2];
+pNew->id = id;
+break;
+}
+}
+return pNew;
+}
+
+/*
+** This routine deallocates a previously allocated mutex.
+*/
+static void debugMutexFree(sqlite3_mutex *p){
+Debug.Assert( p->cnt==0 );
+Debug.Assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
+//sqlite3_free(ref p);
+}
+
+/*
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex.  If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
+** be entered multiple times by the same thread.  In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  If the same thread tries to enter any other kind of mutex
+** more than once, the behavior is undefined.
+*/
+static void debugMutexEnter(sqlite3_mutex *p){
+Debug.Assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(p) );
+p->cnt++;
+}
+static int debugMutexTry(sqlite3_mutex *p){
+Debug.Assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(p) );
+p->cnt++;
+return SQLITE_OK;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  The behavior
+** is undefined if the mutex is not currently entered or
+** is not currently allocated.  SQLite will never do either.
+*/
+static void debugMutexLeave(sqlite3_mutex *p){
+Debug.Assert( debugMutexHeld(p) );
+p->cnt--;
+Debug.Assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(p) );
+}
+
+sqlite3_mutex_methods *sqlite3DefaultMutex(void){
+static sqlite3_mutex_methods sMutex = {
+debugMutexInit,
+debugMutexEnd,
+debugMutexAlloc,
+debugMutexFree,
+debugMutexEnter,
+debugMutexTry,
+debugMutexLeave,
+
+debugMutexHeld,
+debugMutexNotheld
+};
+
+return &sMutex;
+}
+#endif //* (SQLITE_MUTEX_NOOP) && (SQLITE_DEBUG) */
+  }
+}