#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)

#ifdef __OS2__

# include <unistd.h>

#endif

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

#ifndef SQLITE_OMIT_TRACE

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

  struct passwd *pwent;

  uid_t uid = getuid();

  if( (pwent=getpwuid(uid)) != NULL) {

    home_dir = pwent->pw_dir;

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

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

** version 3.7.13.  By combining all the individual C code files into this 

#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)>1

# error "At most one of the following compile-time configuration options\

 is allows: SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG"

#endif

#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)==0

#define SQLITE_VERSION        "3.7.13"

#define SQLITE_VERSION_NUMBER 3007013

#define SQLITE_SOURCE_ID      "2012-06-11 02:05:22 f5b5a13f7394dc143aa136f1d4faba6839eaa6dc"

** is its destructor.  There are many other interfaces (such as

** ^The sqlite3_close() routine is the destructor for the [sqlite3] object.

** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is

** successfully destroyed and all associated resources are deallocated.

**

** Applications must [sqlite3_finalize | finalize] all [prepared statements]

** and [sqlite3_blob_close | close] all [BLOB handles] associated with

** the [sqlite3] object prior to attempting to close the object.  ^If

** outstanding [prepared statements] or [BLOB handles], then it returns

** SQLITE_BUSY.

** ^If [sqlite3_close()] is invoked while a transaction is open,

** The C parameter to [sqlite3_close(C)] must be either a NULL

** ^Calling sqlite3_close() with a NULL pointer argument is a 

** harmless no-op.

SQLITE_API int sqlite3_close(sqlite3 *);

** object returns an integer which is a vector of the these

** ^If the fourth parameter is negative, the length of the string is

** ^The sqlite3_result_toobig() interface causes SQLite to throw an error

** indicating that a string or BLOB is too long to represent.

** ^The sqlite3_result_nomem() interface causes SQLite to throw an error

** indicating that a memory allocation failed.

** <li>   SQLITE_MUTEX_OS2

** a single-threaded application.  ^The SQLITE_MUTEX_OS2,

** SQLITE_MUTEX_PTHREADS, and SQLITE_MUTEX_W32 implementations

** are appropriate for use on OS/2, Unix, and Windows.

** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER 

#   undef SQLITE_OS_OS2

#   define SQLITE_OS_OS2 0

#     define SQLITE_OS_OS2 0

#   elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__)

#     define SQLITE_OS_WIN 0

#     define SQLITE_OS_UNIX 0

#     define SQLITE_OS_OS2 1

#     define SQLITE_OS_OS2 0

#  define SQLITE_OS_OS2 0

#if SQLITE_OS_OS2

# 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_DOSDATETIME

# define INCL_DOSFILEMGR

# define INCL_DOSERRORS

# define INCL_DOSMISC

# define INCL_DOSPROCESS

# define INCL_DOSMODULEMGR

# define INCL_DOSSEMAPHORES

# include <os2.h>

# include <uconv.h>

#endif

** Determine if we are dealing with WindowsRT (Metro) as this has a different and

** incompatible API from win32.

**

**   SQLITE_MUTEX_OS2          For multi-threaded applications on OS/2.

#  elif SQLITE_OS_OS2

#    define SQLITE_MUTEX_OS2

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

                         /* If TK_COLUMN, the value of p5 for OP_Column */

** is intended to be private the the where.c module and should not be

  u8 affinity;      /* Affinity used when eDest==SRT_Set */

  int iParm;        /* A parameter used by the eDest disposal method */

  int iMem;         /* Base register where results are written */

  int nMem;         /* Number of registers allocated */

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

SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *, Mem *);

SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, VdbeCursor *, int *);

SQLITE_PRIVATE int sqlite3VdbeSorterRewind(sqlite3 *, VdbeCursor *, int *);

SQLITE_PRIVATE int sqlite3VdbeSorterWrite(sqlite3 *, VdbeCursor *, Mem *);

SQLITE_PRIVATE int sqlite3VdbeSorterCompare(VdbeCursor *, Mem *, int *);

    bool success;		

    if( !success ){	

/************** Begin file mutex_os2.c ***************************************/

/*

** 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 C functions that implement mutexes for OS/2

*/

/*

** The code in this file is only used if SQLITE_MUTEX_OS2 is defined.

** See the mutex.h file for details.

*/

#ifdef SQLITE_MUTEX_OS2

/********************** OS/2 Mutex Implementation **********************

**

** This implementation of mutexes is built using the OS/2 API.

*/

/*

** The mutex object

** Each recursive mutex is an instance of the following structure.

*/

struct sqlite3_mutex {

  HMTX mutex;       /* Mutex controlling the lock */

  int  id;          /* Mutex type */

#ifdef SQLITE_DEBUG

 int   trace;       /* True to trace changes */

#endif

};

#ifdef SQLITE_DEBUG

#define SQLITE3_MUTEX_INITIALIZER { 0, 0, 0 }

#else

#define SQLITE3_MUTEX_INITIALIZER { 0, 0 }

#endif

/*

** Initialize and deinitialize the mutex subsystem.

*/

static int os2MutexInit(void){ return SQLITE_OK; }

static int os2MutexEnd(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. 

** SQLite will unwind its stack and return an error.  The argument

** to sqlite3_mutex_alloc() is one of these integer constants:

**

** <ul>

** <li>  SQLITE_MUTEX_FAST

** <li>  SQLITE_MUTEX_RECURSIVE

** <li>  SQLITE_MUTEX_STATIC_MASTER

** <li>  SQLITE_MUTEX_STATIC_MEM

** <li>  SQLITE_MUTEX_STATIC_MEM2

** <li>  SQLITE_MUTEX_STATIC_PRNG

** <li>  SQLITE_MUTEX_STATIC_LRU

** <li>  SQLITE_MUTEX_STATIC_LRU2

** </ul>

**

** The first two constants cause sqlite3_mutex_alloc() to create

** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE

** is used but not necessarily so when SQLITE_MUTEX_FAST is used.

** The mutex implementation does not need to make a distinction

** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does

** not want to.  But SQLite will only request a recursive mutex in

** cases where it really needs one.  If a faster non-recursive mutex

** implementation is available on the host platform, the mutex subsystem

** might return such a mutex in response to SQLITE_MUTEX_FAST.

**

** The other allowed parameters to sqlite3_mutex_alloc() each return

** a pointer to a static preexisting mutex.  Six static mutexes are

** used by the current version of SQLite.  Future versions of SQLite

** may add additional static mutexes.  Static mutexes are for internal

** use by SQLite only.  Applications that use SQLite mutexes should

** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or

** SQLITE_MUTEX_RECURSIVE.

**

** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST

** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()

** returns a different mutex on every call.  But for the static

** mutex types, the same mutex is returned on every call that has

** the same type number.

*/

static sqlite3_mutex *os2MutexAlloc(int iType){

  sqlite3_mutex *p = NULL;

  switch( iType ){

    case SQLITE_MUTEX_FAST:

    case SQLITE_MUTEX_RECURSIVE: {

      p = sqlite3MallocZero( sizeof(*p) );

      if( p ){

        p->id = iType;

        if( DosCreateMutexSem( 0, &p->mutex, 0, FALSE ) != NO_ERROR ){

          sqlite3_free( p );

          p = NULL;

        }

      }

      break;

    }

    default: {

      static volatile int isInit = 0;

      static sqlite3_mutex staticMutexes[6] = {

        SQLITE3_MUTEX_INITIALIZER,

        SQLITE3_MUTEX_INITIALIZER,

        SQLITE3_MUTEX_INITIALIZER,

        SQLITE3_MUTEX_INITIALIZER,

        SQLITE3_MUTEX_INITIALIZER,

        SQLITE3_MUTEX_INITIALIZER,

      };

      if ( !isInit ){

        APIRET rc;

        PTIB ptib;

        PPIB ppib;

        HMTX mutex;

        char name[32];

        DosGetInfoBlocks( &ptib, &ppib );

        sqlite3_snprintf( sizeof(name), name, "\\SEM32\\SQLITE%04x",

                          ppib->pib_ulpid );

        while( !isInit ){

          mutex = 0;

          rc = DosCreateMutexSem( name, &mutex, 0, FALSE);

          if( rc == NO_ERROR ){

            unsigned int i;

            if( !isInit ){

              for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){

                DosCreateMutexSem( 0, &staticMutexes[i].mutex, 0, FALSE );

              }

              isInit = 1;

            }

            DosCloseMutexSem( mutex );

          }else if( rc == ERROR_DUPLICATE_NAME ){

            DosSleep( 1 );

          }else{

            return p;

          }

        }

      }

      assert( iType-2 >= 0 );

      assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );

      p = &staticMutexes[iType-2];

      p->id = iType;

      break;

    }

  }

  return p;

}

/*

** This routine deallocates a previously allocated mutex.

** SQLite is careful to deallocate every mutex that it allocates.

*/

static void os2MutexFree(sqlite3_mutex *p){

#ifdef SQLITE_DEBUG

  TID tid;

  PID pid;

  ULONG ulCount;

  DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);

  assert( ulCount==0 );

  assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );

#endif

  DosCloseMutexSem( p->mutex );

  sqlite3_free( p );

}

#ifdef SQLITE_DEBUG

/*

** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are

** intended for use inside assert() statements.

*/

static int os2MutexHeld(sqlite3_mutex *p){

  TID tid;

  PID pid;

  ULONG ulCount;

  PTIB ptib;

  DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);

  if( ulCount==0 || ( ulCount>1 && p->id!=SQLITE_MUTEX_RECURSIVE ) )

    return 0;

  DosGetInfoBlocks(&ptib, NULL);

  return tid==ptib->tib_ptib2->tib2_ultid;

}

static int os2MutexNotheld(sqlite3_mutex *p){

  TID tid;

  PID pid;

  ULONG ulCount;

  PTIB ptib;

  DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);

  if( ulCount==0 )

    return 1;

  DosGetInfoBlocks(&ptib, NULL);

  return tid!=ptib->tib_ptib2->tib2_ultid;

}

static void os2MutexTrace(sqlite3_mutex *p, char *pAction){

  TID   tid;

  PID   pid;

  ULONG ulCount;

  DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);

  printf("%s mutex %p (%d) with nRef=%ld\n", pAction, (void*)p, p->trace, ulCount);

}

#endif

/*

** 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 os2MutexEnter(sqlite3_mutex *p){

  assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );

  DosRequestMutexSem(p->mutex, SEM_INDEFINITE_WAIT);

#ifdef SQLITE_DEBUG

  if( p->trace ) os2MutexTrace(p, "enter");

#endif

}

static int os2MutexTry(sqlite3_mutex *p){

  int rc = SQLITE_BUSY;

  assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );

  if( DosRequestMutexSem(p->mutex, SEM_IMMEDIATE_RETURN) == NO_ERROR ) {

    rc = SQLITE_OK;

#ifdef SQLITE_DEBUG

    if( p->trace ) os2MutexTrace(p, "try");

#endif

  }

  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 or

** is not currently allocated.  SQLite will never do either.

*/

static void os2MutexLeave(sqlite3_mutex *p){

  assert( os2MutexHeld(p) );

  DosReleaseMutexSem(p->mutex);

#ifdef SQLITE_DEBUG

  if( p->trace ) os2MutexTrace(p, "leave");

#endif

}

SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){

  static const sqlite3_mutex_methods sMutex = {

    os2MutexInit,

    os2MutexEnd,

    os2MutexAlloc,

    os2MutexFree,

    os2MutexEnter,

    os2MutexTry,

    os2MutexLeave,

#ifdef SQLITE_DEBUG

    os2MutexHeld,

    os2MutexNotheld

#else

    0,

    0

#endif

  };

  return &sMutex;

}

#endif /* SQLITE_MUTEX_OS2 */

/************** End of mutex_os2.c *******************************************/

SQLITE_API extern void sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */

  if( (*cnt)++ >= 16 ) return '0';

          while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }

          while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }

          while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }

          flag_rtz = 0;

        nsd = 0;

      double scale = 1.0;

  ** allocation as a benign.

/************** Begin file os_os2.c ******************************************/

** 2006 Feb 14

** This file contains code that is specific to OS/2.

#if SQLITE_OS_OS2

** A Note About Memory Allocation:

**

** This driver uses malloc()/free() directly rather than going through

** the SQLite-wrappers sqlite3_malloc()/sqlite3_free().  Those wrappers

** are designed for use on embedded systems where memory is scarce and

** malloc failures happen frequently.  OS/2 does not typically run on

** embedded systems, and when it does the developers normally have bigger

** problems to worry about than running out of memory.  So there is not

** a compelling need to use the wrappers.

** But there is a good reason to not use the wrappers.  If we use the

** wrappers then we will get simulated malloc() failures within this

** driver.  And that causes all kinds of problems for our tests.  We

** could enhance SQLite to deal with simulated malloc failures within

** the OS driver, but the code to deal with those failure would not

** be exercised on Linux (which does not need to malloc() in the driver)

** and so we would have difficulty writing coverage tests for that

** code.  Better to leave the code out, we think.

** The point of this discussion is as follows:  When creating a new

** OS layer for an embedded system, if you use this file as an example,

** avoid the use of malloc()/free().  Those routines work ok on OS/2

** desktops but not so well in embedded systems.

** Macros used to determine whether or not to use threads.

#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE

# define SQLITE_OS2_THREADS 1

/************** Include os_common.h in the middle of os_os2.c ****************/

/************** Begin file os_common.h ***************************************/

/*

** 2004 May 22

**

** 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 macros and a little bit of code that is common to

** all of the platform-specific files (os_*.c) and is #included into those

** files.

**

** This file should be #included by the os_*.c files only.  It is not a

** general purpose header file.

*/

#ifndef _OS_COMMON_H_

#define _OS_COMMON_H_

/*

** At least two bugs have slipped in because we changed the MEMORY_DEBUG

** macro to SQLITE_DEBUG and some older makefiles have not yet made the

** switch.  The following code should catch this problem at compile-time.

*/

#ifdef MEMORY_DEBUG

# error "The MEMORY_DEBUG macro is obsolete.  Use SQLITE_DEBUG instead."

#endif

#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)

# ifndef SQLITE_DEBUG_OS_TRACE

#   define SQLITE_DEBUG_OS_TRACE 0

# endif

  int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;

# define OSTRACE(X)          if( sqlite3OSTrace ) sqlite3DebugPrintf X

#else

# define OSTRACE(X)

#endif

/*

** Macros for performance tracing.  Normally turned off.  Only works

** on i486 hardware.

*/

#ifdef SQLITE_PERFORMANCE_TRACE

/* 

** hwtime.h contains inline assembler code for implementing 

** high-performance timing routines.

*/

/************** Include hwtime.h in the middle of os_common.h ****************/

/************** Begin file hwtime.h ******************************************/

/*

** 2008 May 27

**

** 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 inline asm code for retrieving "high-performance"

** counters for x86 class CPUs.

*/

#ifndef _HWTIME_H_

#define _HWTIME_H_

/*

** The following routine only works on pentium-class (or newer) processors.

** It uses the RDTSC opcode to read the cycle count value out of the

** processor and returns that value.  This can be used for high-res

** profiling.

*/

#if (defined(__GNUC__) || defined(_MSC_VER)) && \

      (defined(i386) || defined(__i386__) || defined(_M_IX86))

  #if defined(__GNUC__)

  __inline__ sqlite_uint64 sqlite3Hwtime(void){

     unsigned int lo, hi;

     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));

     return (sqlite_uint64)hi << 32 | lo;

  }

  #elif defined(_MSC_VER)

  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){

     __asm {

        rdtsc

        ret       ; return value at EDX:EAX

     }

  }

  #endif

#elif (defined(__GNUC__) && defined(__x86_64__))

  __inline__ sqlite_uint64 sqlite3Hwtime(void){

      unsigned long val;

      __asm__ __volatile__ ("rdtsc" : "=A" (val));

      return val;

  }

#elif (defined(__GNUC__) && defined(__ppc__))

  __inline__ sqlite_uint64 sqlite3Hwtime(void){

      unsigned long long retval;

      unsigned long junk;

      __asm__ __volatile__ ("\n\

          1:      mftbu   %1\n\

                  mftb    %L0\n\

                  mftbu   %0\n\

                  cmpw    %0,%1\n\

                  bne     1b"

                  : "=r" (retval), "=r" (junk));

      return retval;

  }

#else

  #error Need implementation of sqlite3Hwtime() for your platform.

  /*

  ** To compile without implementing sqlite3Hwtime() for your platform,

  ** you can remove the above #error and use the following

  ** stub function.  You will lose timing support for many

  ** of the debugging and testing utilities, but it should at

  ** least compile and run.

  */

SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }

#endif

#endif /* !defined(_HWTIME_H_) */

/************** End of hwtime.h **********************************************/

/************** Continuing where we left off in os_common.h ******************/

static sqlite_uint64 g_start;

static sqlite_uint64 g_elapsed;

#define TIMER_START       g_start=sqlite3Hwtime()

#define TIMER_END         g_elapsed=sqlite3Hwtime()-g_start

#define TIMER_ELAPSED     g_elapsed

#else

#define TIMER_START

#define TIMER_END

#define TIMER_ELAPSED     ((sqlite_uint64)0)

#endif

/*

** If we compile with the SQLITE_TEST macro set, then the following block

** of code will give us the ability to simulate a disk I/O error.  This

** is used for testing the I/O recovery logic.

*/

#ifdef SQLITE_TEST

SQLITE_API int sqlite3_io_error_hit = 0;            /* Total number of I/O Errors */

SQLITE_API int sqlite3_io_error_hardhit = 0;        /* Number of non-benign errors */

SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */

SQLITE_API int sqlite3_io_error_persist = 0;        /* True if I/O errors persist */

SQLITE_API int sqlite3_io_error_benign = 0;         /* True if errors are benign */

SQLITE_API int sqlite3_diskfull_pending = 0;

SQLITE_API int sqlite3_diskfull = 0;

#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)

#define SimulateIOError(CODE)  \

  if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \

       || sqlite3_io_error_pending-- == 1 )  \

              { local_ioerr(); CODE; }

static void local_ioerr(){

  IOTRACE(("IOERR\n"));

  sqlite3_io_error_hit++;

  if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;

}

#define SimulateDiskfullError(CODE) \

   if( sqlite3_diskfull_pending ){ \

     if( sqlite3_diskfull_pending == 1 ){ \

       local_ioerr(); \

       sqlite3_diskfull = 1; \

       sqlite3_io_error_hit = 1; \

       CODE; \

     }else{ \

       sqlite3_diskfull_pending--; \

     } \

   }

#else

#define SimulateIOErrorBenign(X)

#define SimulateIOError(A)

#define SimulateDiskfullError(A)

#endif

/*

** When testing, keep a count of the number of open files.

*/

#ifdef SQLITE_TEST

SQLITE_API int sqlite3_open_file_count = 0;

#define OpenCounter(X)  sqlite3_open_file_count+=(X)

#else

#define OpenCounter(X)

#endif

#endif /* !defined(_OS_COMMON_H_) */

/************** End of os_common.h *******************************************/

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

/* Forward references */

typedef struct os2File os2File;         /* The file structure */

typedef struct os2ShmNode os2ShmNode;   /* A shared descritive memory node */

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

/*

** The os2File structure is subclass of sqlite3_file specific for the OS/2

** protability layer.

*/

struct os2File {

  const sqlite3_io_methods *pMethod;  /* Always the first entry */

  HFILE h;                  /* Handle for accessing the file */

  int flags;                /* Flags provided to os2Open() */

  int locktype;             /* Type of lock currently held on this file */

  int szChunk;              /* Chunk size configured by FCNTL_CHUNK_SIZE */

  char *zFullPathCp;        /* Full path name of this file */

  os2ShmLink *pShmLink;     /* Instance of shared memory on this file */

};

#define LOCK_TIMEOUT 10L /* the default locking timeout */

/*

** Missing from some versions of the OS/2 toolkit -

** used to allocate from high memory if possible

*/

#ifndef OBJ_ANY

# define OBJ_ANY 0x00000400

#endif

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

** The next group of routines implement the I/O methods specified

** by the sqlite3_io_methods object.

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

/*

** Close a file.

*/

static int os2Close( sqlite3_file *id ){

  APIRET rc;

  os2File *pFile = (os2File*)id;

  assert( id!=0 );

  OSTRACE(( "CLOSE %d (%s)\n", pFile->h, pFile->zFullPathCp ));

  rc = DosClose( pFile->h );

  if( pFile->flags & SQLITE_OPEN_DELETEONCLOSE )

    DosForceDelete( (PSZ)pFile->zFullPathCp );

  free( pFile->zFullPathCp );

  pFile->zFullPathCp = NULL;

  pFile->locktype = NO_LOCK;

  pFile->h = (HFILE)-1;

  pFile->flags = 0;

  OpenCounter( -1 );

  return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;

}

/*

** Read data from a file into a buffer.  Return SQLITE_OK if all

** bytes were read successfully and SQLITE_IOERR if anything goes

** wrong.

*/

static int os2Read(

  sqlite3_file *id,               /* File to read from */

  void *pBuf,                     /* Write content into this buffer */

  int amt,                        /* Number of bytes to read */

  sqlite3_int64 offset            /* Begin reading at this offset */

){

  ULONG fileLocation = 0L;

  ULONG got;

  os2File *pFile = (os2File*)id;

  assert( id!=0 );

  SimulateIOError( return SQLITE_IOERR_READ );

  OSTRACE(( "READ %d lock=%d\n", pFile->h, pFile->locktype ));

  if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){

    return SQLITE_IOERR;

  }

  if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){

    return SQLITE_IOERR_READ;

  }

  if( got == (ULONG)amt )

    return SQLITE_OK;

  else {

    /* Unread portions of the input buffer must be zero-filled */

    memset(&((char*)pBuf)[got], 0, amt-got);

    return SQLITE_IOERR_SHORT_READ;

  }

}

/*

** Write data from a buffer into a file.  Return SQLITE_OK on success

** or some other error code on failure.

*/

static int os2Write(

  sqlite3_file *id,               /* File to write into */

  const void *pBuf,               /* The bytes to be written */

  int amt,                        /* Number of bytes to write */

  sqlite3_int64 offset            /* Offset into the file to begin writing at */

){

  ULONG fileLocation = 0L;

  APIRET rc = NO_ERROR;

  ULONG wrote;

  os2File *pFile = (os2File*)id;

  assert( id!=0 );

  SimulateIOError( return SQLITE_IOERR_WRITE );

  SimulateDiskfullError( return SQLITE_FULL );

  OSTRACE(( "WRITE %d lock=%d\n", pFile->h, pFile->locktype ));

  if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){

    return SQLITE_IOERR;

  }

  assert( amt>0 );

  while( amt > 0 &&

         ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&

         wrote > 0

  ){

    amt -= wrote;

    pBuf = &((char*)pBuf)[wrote];

  }

  return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLITE_FULL : SQLITE_OK;

}

/*

** Truncate an open file to a specified size

*/

static int os2Truncate( sqlite3_file *id, i64 nByte ){

  APIRET rc;

  os2File *pFile = (os2File*)id;

  assert( id!=0 );

  OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));

  SimulateIOError( return SQLITE_IOERR_TRUNCATE );

  /* If the user has configured a chunk-size for this file, truncate the

  ** file so that it consists of an integer number of chunks (i.e. the

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

  ** size).

  */

  if( pFile->szChunk ){

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

  }

  rc = DosSetFileSize( pFile->h, nByte );

  return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR_TRUNCATE;

}

#ifdef SQLITE_TEST

/*

** Count the number of fullsyncs and normal syncs.  This is used to test

** that syncs and fullsyncs are occuring at the right times.

*/

SQLITE_API int sqlite3_sync_count = 0;

SQLITE_API int sqlite3_fullsync_count = 0;

#endif

/*

** Make sure all writes to a particular file are committed to disk.

*/

static int os2Sync( sqlite3_file *id, int flags ){

  os2File *pFile = (os2File*)id;

  OSTRACE(( "SYNC %d lock=%d\n", pFile->h, pFile->locktype ));

#ifdef SQLITE_TEST

  if( flags & SQLITE_SYNC_FULL){

    sqlite3_fullsync_count++;

  }

  sqlite3_sync_count++;

#endif

  /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a

  ** no-op

  */

#ifdef SQLITE_NO_SYNC

  UNUSED_PARAMETER(pFile);

  return SQLITE_OK;

#else

  return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;