System.Data.SQLite

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that used to generate VDBE code
** that implements the ALTER TABLE command.
**
** $Id: alter.c,v 1.24 2006/10/12 21:34:20 rmsimpson Exp $
** $Id: alter.c,v 1.25 2007/01/10 14:50:45 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

/*
** The code in this file only exists if we are not omitting the
** ALTER TABLE logic from the build.

/*
** 2005 July 8
**
** 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 code associated with the ANALYZE command.
**
** @(#) $Id: analyze.c,v 1.17 2006/10/12 21:34:20 rmsimpson Exp $
** @(#) $Id: analyze.c,v 1.18 2007/01/10 14:50:45 rmsimpson Exp $
*/
#ifndef SQLITE_OMIT_ANALYZE
#include "sqliteInt.h"

/*
** This routine generates code that opens the sqlite_stat1 table on cursor
** iStatCur.

/*
** 2003 April 6
**
** 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 code used to implement the ATTACH and DETACH commands.
**
** $Id: attach.c,v 1.23 2006/10/12 21:34:20 rmsimpson Exp $
** $Id: attach.c,v 1.24 2007/01/10 14:50:45 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** Resolve an expression that was part of an ATTACH or DETACH statement. This
** is slightly different from resolving a normal SQL expression, because simple
** identifiers are treated as strings, not possible column names or aliases.

**
*************************************************************************
** This file contains code used to implement the sqlite3_set_authorizer()
** API.  This facility is an optional feature of the library.  Embedded
** systems that do not need this facility may omit it by recompiling
** the library with -DSQLITE_OMIT_AUTHORIZATION=1
**
** $Id: auth.c,v 1.23 2006/10/12 21:34:20 rmsimpson Exp $
** $Id: auth.c,v 1.24 2007/01/10 14:50:45 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** All of the code in this file may be omitted by defining a single
** macro.
*/

/*
** 2004 April 6
**
** 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.
**
*************************************************************************
** $Id: btree.c,v 1.26 2006/10/12 21:34:20 rmsimpson Exp $
** $Id: btree.c,v 1.27 2007/01/10 14:50:45 rmsimpson Exp $
**
** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to
**
**     Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
**     "Sorting And Searching", pages 473-480. Addison-Wesley
**     Publishing Company, Reading, Massachusetts.

/*
** The TRACE macro will print high-level status information about the
** btree operation when the global variable sqlite3_btree_trace is
** enabled.
*/
#if SQLITE_TEST
# define TRACE(X)   if( sqlite3_btree_trace )\
/*                        { sqlite3DebugPrintf X; fflush(stdout); } */ \
                        { sqlite3DebugPrintf X; fflush(stdout); }
{ printf X; fflush(stdout); }
int sqlite3_btree_trace=0;  /* True to enable tracing */
#else
# define TRACE(X)
#endif

/*
** Forward declaration

  u8 *pCell;
  pCell = findOverflowCell(pPage, iCell);
  return ptrmapPutOvflPtr(pPage, pCell);
}
#endif


/*
** Do sanity checking on a page.  Throw an exception if anything is
** not right.
**
** This routine is used for internal error checking only.  It is omitted
** from most builds.
*/
#if defined(BTREE_DEBUG) && !defined(NDEBUG) && 0
static void _pageIntegrity(MemPage *pPage){
  int usableSize;
  u8 *data;
  int i, j, idx, c, pc, hdr, nFree;
  int cellOffset;
  int nCell, cellLimit;
  u8 *used;

  used = sqliteMallocRaw( pPage->pBt->pageSize );
  if( used==0 ) return;
  usableSize = pPage->pBt->usableSize;
  assert( pPage->aData==&((unsigned char*)pPage)[-pPage->pBt->pageSize] );
  hdr = pPage->hdrOffset;
  assert( hdr==(pPage->pgno==1 ? 100 : 0) );
  assert( pPage->pgno==sqlite3pager_pagenumber(pPage->aData) );
  c = pPage->aData[hdr];
  if( pPage->isInit ){
    assert( pPage->leaf == ((c & PTF_LEAF)!=0) );
    assert( pPage->zeroData == ((c & PTF_ZERODATA)!=0) );
    assert( pPage->leafData == ((c & PTF_LEAFDATA)!=0) );
    assert( pPage->intKey == ((c & (PTF_INTKEY|PTF_LEAFDATA))!=0) );
    assert( pPage->hasData ==
             !(pPage->zeroData || (!pPage->leaf && pPage->leafData)) );
    assert( pPage->cellOffset==pPage->hdrOffset+12-4*pPage->leaf );
    assert( pPage->nCell = get2byte(&pPage->aData[hdr+3]) );
  }
  data = pPage->aData;
  memset(used, 0, usableSize);
  for(i=0; i<hdr+10-pPage->leaf*4; i++) used[i] = 1;
  nFree = 0;
  pc = get2byte(&data[hdr+1]);
  while( pc ){
    int size;
    assert( pc>0 && pc<usableSize-4 );
    size = get2byte(&data[pc+2]);
    assert( pc+size<=usableSize );
    nFree += size;
    for(i=pc; i<pc+size; i++){
      assert( used[i]==0 );
      used[i] = 1;
    }
    pc = get2byte(&data[pc]);
  }
  idx = 0;
  nCell = get2byte(&data[hdr+3]);
  cellLimit = get2byte(&data[hdr+5]);
  assert( pPage->isInit==0 
         || pPage->nFree==nFree+data[hdr+7]+cellLimit-(cellOffset+2*nCell) );
  cellOffset = pPage->cellOffset;
  for(i=0; i<nCell; i++){
    int size;
    pc = get2byte(&data[cellOffset+2*i]);
    assert( pc>0 && pc<usableSize-4 );
    size = cellSize(pPage, &data[pc]);
    assert( pc+size<=usableSize );
    for(j=pc; j<pc+size; j++){
      assert( used[j]==0 );
      used[j] = 1;
    }
  }
  for(i=cellOffset+2*nCell; i<cellimit; i++){
    assert( used[i]==0 );
    used[i] = 1;
  }
  nFree = 0;
  for(i=0; i<usableSize; i++){
    assert( used[i]<=1 );
    if( used[i]==0 ) nFree++;
  }
  assert( nFree==data[hdr+7] );
  sqliteFree(used);
}
#define pageIntegrity(X) _pageIntegrity(X)
#else
# define pageIntegrity(X)
#endif

/* A bunch of assert() statements to check the transaction state variables
** of handle p (type Btree*) are internally consistent.
*/
#define btreeIntegrity(p) \
  assert( p->inTrans!=TRANS_NONE || p->pBt->nTransaction<p->pBt->nRef ); \
  assert( p->pBt->nTransaction<=p->pBt->nRef ); \
  assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \

  pPage->nFree = nFree;
  if( nFree>=usableSize ){
    /* Free space cannot exceed total page size */
    return SQLITE_CORRUPT_BKPT; 
  }

  pPage->isInit = 1;
  pageIntegrity(pPage);
  return SQLITE_OK;
}

/*
** Set up a raw page so that it looks like a database page holding
** no entries.
*/

  decodeFlags(pPage, flags);
  pPage->hdrOffset = hdr;
  pPage->cellOffset = first;
  pPage->nOverflow = 0;
  pPage->idxShift = 0;
  pPage->nCell = 0;
  pPage->isInit = 1;
  pageIntegrity(pPage);
}

/*
** Get a page from the pager.  Initialize the MemPage.pBt and
** MemPage.aData elements if needed.
*/
static int getPage(BtShared *pBt, Pgno pgno, MemPage **ppPage){

  pBt = sqliteMalloc( sizeof(*pBt) );
  if( pBt==0 ){
    *ppBtree = 0;
    sqliteFree(p);
    return SQLITE_NOMEM;
  }
  rc = sqlite3pager_open(&pBt->pPager, zFilename, EXTRA_SIZE, flags);
  if( rc==SQLITE_OK ){
    rc = sqlite3pager_read_fileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
  }
  if( rc!=SQLITE_OK ){
    if( pBt->pPager ){
    if( pBt->pPager ) sqlite3pager_close(pBt->pPager);
      sqlite3pager_close(pBt->pPager);
    }
    sqliteFree(pBt);
    sqliteFree(p);
    *ppBtree = 0;
    return rc;
  }
  p->pBt = pBt;

  sqlite3pager_set_destructor(pBt->pPager, pageDestructor);
  sqlite3pager_set_reiniter(pBt->pPager, pageReinit);
  pBt->pCursor = 0;
  pBt->pPage1 = 0;
  pBt->readOnly = sqlite3pager_isreadonly(pBt->pPager);
  sqlite3pager_read_fileheader(pBt->pPager, sizeof(zDbHeader), zDbHeader);
  pBt->pageSize = get2byte(&zDbHeader[16]);
  if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
       || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
    pBt->pageSize = SQLITE_DEFAULT_PAGE_SIZE;
    pBt->maxEmbedFrac = 64;   /* 25% */
    pBt->minEmbedFrac = 32;   /* 12.5% */
    pBt->minLeafFrac = 32;    /* 12.5% */

**
** If there are any outstanding cursors, this routine is a no-op.
**
** If there is a transaction in progress, this routine is a no-op.
*/
static void unlockBtreeIfUnused(BtShared *pBt){
  if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){
    if( sqlite3pager_refcount(pBt->pPager)>=1 ){
    if( pBt->pPage1->aData==0 ){
      MemPage *pPage = pBt->pPage1;
      pPage->aData = &((u8*)pPage)[-pBt->pageSize];
      pPage->pBt = pBt;
      pPage->pgno = 1;
    }
    releasePage(pBt->pPage1);
      if( pBt->pPage1->aData==0 ){
        MemPage *pPage = pBt->pPage1;
        pPage->aData = &((u8*)pPage)[-pBt->pageSize];
        pPage->pBt = pBt;
        pPage->pgno = 1;
      }
      releasePage(pBt->pPage1);
    }
    pBt->pPage1 = 0;
    pBt->inStmt = 0;
  }
}

/*
** Create a new database by initializing the first page of the

  int ovflSize;
  u32 nKey;

  assert( pCur!=0 && pCur->pPage!=0 );
  assert( pCur->eState==CURSOR_VALID );
  pBt = pCur->pBtree->pBt;
  pPage = pCur->pPage;
  pageIntegrity(pPage);
  assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
  getCellInfo(pCur);
  aPayload = pCur->info.pCell + pCur->info.nHeader;
  if( pPage->intKey ){
    nKey = 0;
  }else{
    nKey = pCur->info.nKey;

  MemPage *pPage;
  u32 nKey;
  int nLocal;

  assert( pCur!=0 && pCur->pPage!=0 );
  assert( pCur->eState==CURSOR_VALID );
  pPage = pCur->pPage;
  pageIntegrity(pPage);
  assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
  getCellInfo(pCur);
  aPayload = pCur->info.pCell;
  aPayload += pCur->info.nHeader;
  if( pPage->intKey ){
    nKey = 0;
  }else{

  MemPage *pNewPage;
  MemPage *pOldPage;
  BtShared *pBt = pCur->pBtree->pBt;

  assert( pCur->eState==CURSOR_VALID );
  rc = getAndInitPage(pBt, newPgno, &pNewPage, pCur->pPage);
  if( rc ) return rc;
  pageIntegrity(pNewPage);
  pNewPage->idxParent = pCur->idx;
  pOldPage = pCur->pPage;
  pOldPage->idxShift = 0;
  releasePage(pOldPage);
  pCur->pPage = pNewPage;
  pCur->idx = 0;
  pCur->info.nSize = 0;

  MemPage *pPage;
  int idxParent;

  assert( pCur->eState==CURSOR_VALID );
  pPage = pCur->pPage;
  assert( pPage!=0 );
  assert( !isRootPage(pPage) );
  pageIntegrity(pPage);
  pParent = pPage->pParent;
  assert( pParent!=0 );
  pageIntegrity(pParent);
  idxParent = pPage->idxParent;
  sqlite3pager_ref(pParent->aData);
  releasePage(pPage);
  pCur->pPage = pParent;
  pCur->info.nSize = 0;
  assert( pParent->idxShift==0 );
  pCur->idx = idxParent;

    if( 
      SQLITE_OK!=(rc = getAndInitPage(pBt, pCur->pgnoRoot, &pRoot, 0))
    ){
      pCur->eState = CURSOR_INVALID;
      return rc;
    }
    releasePage(pCur->pPage);
    pageIntegrity(pRoot);
    pCur->pPage = pRoot;
  }
  pCur->idx = 0;
  pCur->info.nSize = 0;
  if( pRoot->nCell==0 && !pRoot->leaf ){
    Pgno subpage;
    assert( pRoot->pgno==1 );

  assert( pCur->pPage->isInit );
  tryRightmost = pCur->pPage->intKey;
  if( pCur->eState==CURSOR_INVALID ){
    *pRes = -1;
    assert( pCur->pPage->nCell==0 );
    return SQLITE_OK;
  }
   for(;;){
  for(;;){
    int lwr, upr;
    Pgno chldPg;
    MemPage *pPage = pCur->pPage;
    int c = -1;  /* pRes return if table is empty must be -1 */
    lwr = 0;
    upr = pPage->nCell-1;
    if( !pPage->intKey && pKey==0 ){
      return SQLITE_CORRUPT_BKPT;
    }
    pageIntegrity(pPage);
    while( lwr<=upr ){
      void *pCellKey;
      i64 nCellKey;
      pCur->idx = (lwr+upr)/2;
      pCur->info.nSize = 0;
      if( pPage->intKey ){
        u8 *pCell;

  Pgno nearby,
  u8 exact
){
  MemPage *pPage1;
  int rc;
  int n;     /* Number of pages on the freelist */
  int k;     /* Number of leaves on the trunk of the freelist */
  MemPage *pTrunk = 0;
  MemPage *pPrevTrunk = 0;

  pPage1 = pBt->pPage1;
  n = get4byte(&pPage1->aData[36]);
  if( n>0 ){
    /* There are pages on the freelist.  Reuse one of those pages. */
    MemPage *pTrunk = 0;
    Pgno iTrunk;
    MemPage *pPrevTrunk = 0;
    u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
    
    /* If the 'exact' parameter was true and a query of the pointer-map
    ** shows that the page 'nearby' is somewhere on the free-list, then
    ** the entire-list will be searched for that page.
    */
#ifndef SQLITE_OMIT_AUTOVACUUM

      if( pPrevTrunk ){
        iTrunk = get4byte(&pPrevTrunk->aData[0]);
      }else{
        iTrunk = get4byte(&pPage1->aData[32]);
      }
      rc = getPage(pBt, iTrunk, &pTrunk);
      if( rc ){
        releasePage(pPrevTrunk);
        pTrunk = 0;
        return rc;
      }

        goto end_allocate_page;
      /* TODO: This should move to after the loop? */
      rc = sqlite3pager_write(pTrunk->aData);
      if( rc ){
        releasePage(pTrunk);
        releasePage(pPrevTrunk);
        return rc;
      }

      k = get4byte(&pTrunk->aData[4]);
      if( k==0 && !searchList ){
        /* The trunk has no leaves and the list is not being searched. 
        ** So extract the trunk page itself and use it as the newly 
        ** allocated page */
        assert( pPrevTrunk==0 );
        rc = sqlite3pager_write(pTrunk->aData);
        if( rc ){
          goto end_allocate_page;
        }
        *pPgno = iTrunk;
        memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
        *ppPage = pTrunk;
        pTrunk = 0;
        TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
      }else if( k>pBt->usableSize/4 - 8 ){
        /* Value of k is out of range.  Database corruption */
        return SQLITE_CORRUPT_BKPT;
        rc = SQLITE_CORRUPT_BKPT;
        goto end_allocate_page;
#ifndef SQLITE_OMIT_AUTOVACUUM
      }else if( searchList && nearby==iTrunk ){
        /* The list is being searched and this trunk page is the page
        ** to allocate, regardless of whether it has leaves.
        */
        assert( *pPgno==iTrunk );
        *ppPage = pTrunk;
        searchList = 0;
        rc = sqlite3pager_write(pTrunk->aData);
        if( rc ){
          goto end_allocate_page;
        }
        if( k==0 ){
          if( !pPrevTrunk ){
            memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
          }else{
            memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
          }
        }else{
          /* The trunk page is required by the caller but it contains 
          ** pointers to free-list leaves. The first leaf becomes a trunk
          ** page in this case.
          */
          MemPage *pNewTrunk;
          Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
          rc = getPage(pBt, iNewTrunk, &pNewTrunk);
          if( rc!=SQLITE_OK ){
            releasePage(pTrunk);
            goto end_allocate_page;
            releasePage(pPrevTrunk);
            return rc;
          }
          rc = sqlite3pager_write(pNewTrunk->aData);
          if( rc!=SQLITE_OK ){
            releasePage(pNewTrunk);
            releasePage(pTrunk);
            goto end_allocate_page;
            releasePage(pPrevTrunk);
            return rc;
          }
          memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
          put4byte(&pNewTrunk->aData[4], k-1);
          memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
          releasePage(pNewTrunk);
          if( !pPrevTrunk ){
            put4byte(&pPage1->aData[32], iNewTrunk);
          }else{
            rc = sqlite3pager_write(pPrevTrunk->aData);
            if( rc ){
              goto end_allocate_page;
            }
            put4byte(&pPrevTrunk->aData[0], iNewTrunk);
          }
          releasePage(pNewTrunk);
        }
        pTrunk = 0;
        TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
#endif
      }else{
        /* Extract a leaf from the trunk */
        int closest;
        Pgno iPage;
        unsigned char *aData = pTrunk->aData;
        rc = sqlite3pager_write(aData);
        if( rc ){
          goto end_allocate_page;
        }
        if( nearby>0 ){
          int i, dist;
          closest = 0;
          dist = get4byte(&aData[8]) - nearby;
          if( dist<0 ) dist = -dist;
          for(i=1; i<k; i++){
            int d2 = get4byte(&aData[8+i*4]) - nearby;

              releasePage(*ppPage);
            }
          }
          searchList = 0;
        }
      }
      releasePage(pPrevTrunk);
      pPrevTrunk = 0;
    }while( searchList );
    releasePage(pTrunk);
  }else{
    /* There are no pages on the freelist, so create a new page at the
    ** end of the file */
    *pPgno = sqlite3pager_pagecount(pBt->pPager) + 1;

#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){

    if( rc!=SQLITE_OK ){
      releasePage(*ppPage);
    }
    TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
  }

  assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );

end_allocate_page:
  releasePage(pTrunk);
  releasePage(pPrevTrunk);
  return rc;
}

/*
** Add a page of the database file to the freelist.
**
** sqlite3pager_unref() is NOT called for pPage.

    for(j=end-2, ptr=&data[j]; j>ins; j-=2, ptr-=2){
      ptr[0] = ptr[-2];
      ptr[1] = ptr[-1];
    }
    put2byte(&data[ins], idx);
    put2byte(&data[hdr+3], pPage->nCell);
    pPage->idxShift = 1;
    pageIntegrity(pPage);
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pPage->pBt->autoVacuum ){
      /* The cell may contain a pointer to an overflow page. If so, write
      ** the entry for the overflow page into the pointer map.
      */
      CellInfo info;
      parseCellPtr(pPage, pCell, &info);

  /*
  ** Balance the parent page.  Note that the current page (pPage) might
  ** have been added to the freelist so it might no longer be initialized.
  ** But the parent page will always be initialized.
  */
  assert( pParent->isInit );
  /* assert( pPage->isInit ); // No! pPage might have been added to freelist */
  /* pageIntegrity(pPage);    // No! pPage might have been added to freelist */ 
  rc = balance(pParent, 0);
  
  /*
  ** Cleanup before returning.
  */
balance_cleanup:
  sqliteFree(apCell);

  BtCursor tmpCur;

  int rc = restoreOrClearCursorPosition(pCur, 1);
  if( rc!=SQLITE_OK ){
    return rc;
  }

  pageIntegrity(pPage);
  assert( pPage->isInit );
  getTempCursor(pCur, &tmpCur);
  while( upCnt-- ){
    moveToParent(&tmpCur);
  }
  pPage = tmpCur.pPage;
  pageIntegrity(pPage);
  aResult[0] = sqlite3pager_pagenumber(pPage->aData);
  assert( aResult[0]==pPage->pgno );
  aResult[1] = tmpCur.idx;
  aResult[2] = pPage->nCell;
  if( tmpCur.idx>=0 && tmpCur.idx<pPage->nCell ){
    getCellInfo(&tmpCur);
    aResult[3] = tmpCur.info.nSize;

  iSkip = PENDING_BYTE_PAGE(pBtTo);
  for(i=1; rc==SQLITE_OK && i<=nPage; i++){
    void *pPage;
    if( i==iSkip ) continue;
    rc = sqlite3pager_get(pBtFrom->pPager, i, &pPage);
    if( rc ) break;
    rc = sqlite3pager_overwrite(pBtTo->pPager, i, pPage);
    if( rc ) break;
    sqlite3pager_unref(pPage);
  }
  for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){
    void *pPage;
    if( i==iSkip ) continue;
    rc = sqlite3pager_get(pBtTo->pPager, i, &pPage);
    if( rc ) break;

**    May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the interface that the sqlite B-Tree file
** subsystem.  See comments in the source code for a detailed description
** of what each interface routine does.
**
** @(#) $Id: btree.h,v 1.24 2006/10/12 21:34:21 rmsimpson Exp $
** @(#) $Id: btree.h,v 1.25 2007/01/10 14:50:45 rmsimpson Exp $
*/
#ifndef _BTREE_H_
#define _BTREE_H_

/* TODO: This definition is just included so other modules compile. It
** needs to be revisited.
*/

**     CREATE INDEX
**     DROP INDEX
**     creating ID lists
**     BEGIN TRANSACTION
**     COMMIT
**     ROLLBACK
**
** $Id: build.c,v 1.24 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: build.c,v 1.25 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

/*
** This routine is called when a new SQL statement is beginning to
** be parsed.  Initialize the pParse structure as needed.

      if( pItem->pSelect ){
        sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
      }
    }
  }
}

/*
** Add an alias to the last identifier on the given identifier list.
*/
void sqlite3SrcListAddAlias(SrcList *pList, Token *pToken){
  if( pList && pList->nSrc>0 ){
    pList->a[pList->nSrc-1].zAlias = sqlite3NameFromToken(pToken);
  }
}

/*
** Delete an entire SrcList including all its substructure.
*/
void sqlite3SrcListDelete(SrcList *pList){
  int i;
  struct SrcList_item *pItem;
  if( pList==0 ) return;
  for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
    sqliteFree(pItem->zDatabase);
    sqliteFree(pItem->zName);
    sqliteFree(pItem->zAlias);
    sqlite3DeleteTable(0, pItem->pTab);
    sqlite3SelectDelete(pItem->pSelect);
    sqlite3ExprDelete(pItem->pOn);
    sqlite3IdListDelete(pItem->pUsing);
  }
  sqliteFree(pList);
}

/*
** This routine is called by the parser to add a new term to the
** end of a growing FROM clause.  The "p" parameter is the part of
** the FROM clause that has already been constructed.  "p" is NULL
** if this is the first term of the FROM clause.  pTable and pDatabase
** are the name of the table and database named in the FROM clause term.
** pDatabase is NULL if the database name qualifier is missing - the
** usual case.  If the term has a alias, then pAlias points to the
** alias token.  If the term is a subquery, then pSubquery is the
** SELECT statement that the subquery encodes.  The pTable and
** pDatabase parameters are NULL for subqueries.  The pOn and pUsing
** parameters are the content of the ON and USING clauses.
**
** Return a new SrcList which encodes is the FROM with the new
** term added.
*/
SrcList *sqlite3SrcListAppendFromTerm(
  SrcList *p,             /* The left part of the FROM clause already seen */
  Token *pTable,          /* Name of the table to add to the FROM clause */
  Token *pDatabase,       /* Name of the database containing pTable */
  Token *pAlias,          /* The right-hand side of the AS subexpression */
  Select *pSubquery,      /* A subquery used in place of a table name */
  Expr *pOn,              /* The ON clause of a join */
  IdList *pUsing          /* The USING clause of a join */
){
  struct SrcList_item *pItem;
  p = sqlite3SrcListAppend(p, pTable, pDatabase);
  if( p==0 || p->nSrc==0 ){
    sqlite3ExprDelete(pOn);
    sqlite3IdListDelete(pUsing);
    sqlite3SelectDelete(pSubquery);
    return p;
  }
  pItem = &p->a[p->nSrc-1];
  if( pAlias && pAlias->n ){
    pItem->zAlias = sqlite3NameFromToken(pAlias);
  }
  pItem->pSelect = pSubquery;
  pItem->pOn = pOn;
  pItem->pUsing = pUsing;
  return p;
}

/*
** When building up a FROM clause in the parser, the join operator
** is initially attached to the left operand.  But the code generator
** expects the join operator to be on the right operand.  This routine
** Shifts all join operators from left to right for an entire FROM
** clause.
**
** Example: Suppose the join is like this:
**
**           A natural cross join B
**
** The operator is "natural cross join".  The A and B operands are stored
** in p->a[0] and p->a[1], respectively.  The parser initially stores the
** operator with A.  This routine shifts that operator over to B.
*/
void sqlite3SrcListShiftJoinType(SrcList *p){
  if( p && p->a ){
    int i;
    for(i=p->nSrc-1; i>0; i--){
      p->a[i].jointype = p->a[i-1].jointype;
    }
    p->a[0].jointype = 0;
  }
}

/*
** Begin a transaction
*/
void sqlite3BeginTransaction(Parse *pParse, int type){
  sqlite3 *db;
  Vdbe *v;

**    May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains functions used to access the internal hash tables
** of user defined functions and collation sequences.
**
** $Id: callback.c,v 1.19 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: callback.c,v 1.20 2007/01/10 14:50:46 rmsimpson Exp $
*/

#include "sqliteInt.h"

/*
** Invoke the 'collation needed' callback to request a collation sequence
** in the database text encoding of name zName, length nName.

** An tokenizer for SQL
**
** This file contains C code that implements the sqlite3_complete() API.
** This code used to be part of the tokenizer.c source file.  But by
** separating it out, the code will be automatically omitted from
** static links that do not use it.
**
** $Id: complete.c,v 1.17 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: complete.c,v 1.18 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"
#ifndef SQLITE_OMIT_COMPLETE

/*
** This is defined in tokenize.c.  We just have to import the definition.
*/

** This file contains the C functions that implement date and time
** functions for SQLite.  
**
** There is only one exported symbol in this file - the function
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope.
**
** $Id: date.c,v 1.25 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: date.c,v 1.26 2007/01/10 14:50:46 rmsimpson Exp $
**
** NOTES:
**
** SQLite processes all times and dates as Julian Day numbers.  The
** dates and times are stored as the number of days since noon
** in Greenwich on November 24, 4714 B.C. according to the Gregorian
** calendar system. 

        case 'j': {
          int nDay;             /* Number of days since 1st day of year */
          DateTime y = x;
          y.validJD = 0;
          y.M = 1;
          y.D = 1;
          computeJD(&y);
          nDay = x.rJD - y.rJD;
          nDay = x.rJD - y.rJD + 0.5;
          if( zFmt[i]=='W' ){
            int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
            wd = ((int)(x.rJD+0.5)) % 7;
            sprintf(&z[j],"%02d",(nDay+7-wd)/7);
            j += 2;
          }else{
            sprintf(&z[j],"%03d",nDay+1);
            j += 3;
          }
          break;
        }
        case 'J':  sprintf(&z[j],"%.16g",x.rJD); j+=strlen(&z[j]); break;
        case 'm':  sprintf(&z[j],"%02d",x.M); j+=2; break;
        case 'M':  sprintf(&z[j],"%02d",x.m); j+=2; break;
        case 's': {
          sprintf(&z[j],"%d",(int)((x.rJD-2440587.5)*86400.0 + 0.5));
          j += strlen(&z[j]);
          break;
        }
        case 'S':  sprintf(&z[j],"%02d",(int)(x.s+0.5)); j+=2; break;
        case 'S':  sprintf(&z[j],"%02d",(int)x.s); j+=2; break;
        case 'w':  z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break;
        case 'Y':  sprintf(&z[j],"%04d",x.Y); j+=strlen(&z[j]); break;
        case '%':  z[j++] = '%'; break;
      }
    }
  }
  z[j] = 0;

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that are called by the parser
** in order to generate code for DELETE FROM statements.
**
** $Id: delete.c,v 1.24 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: delete.c,v 1.25 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** Look up every table that is named in pSrc.  If any table is not found,
** add an error message to pParse->zErrMsg and return NULL.  If all tables
** are found, return a pointer to the last table.

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
** $Id: expr.c,v 1.31 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: expr.c,v 1.32 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

/*
** Return the 'affinity' of the expression pExpr if any.
**

            pExpr->iTable = pItem->iCursor;
            pMatch = pItem;
            pExpr->pSchema = pTab->pSchema;
            /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
            pExpr->iColumn = j==pTab->iPKey ? -1 : j;
            pExpr->affinity = pTab->aCol[j].affinity;
            pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);
            if( i<pSrcList->nSrc-1 ){
            if( pItem->jointype & JT_NATURAL ){
              /* If this match occurred in the left table of a natural join,
              ** then skip the right table to avoid a duplicate match */
              pItem++;
              i++;
              if( pItem[1].jointype & JT_NATURAL ){
                /* If this match occurred in the left table of a natural join,
                ** then skip the right table to avoid a duplicate match */
                pItem++;
                i++;
            }
            if( (pUsing = pItem->pUsing)!=0 ){
              /* If this match occurs on a column that is in the USING clause
              ** of a join, skip the search of the right table of the join
              ** to avoid a duplicate match there. */
              int k;
              for(k=0; k<pUsing->nId; k++){
                if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){
                  pItem++;
                  i++;
                  break;
              }else if( (pUsing = pItem[1].pUsing)!=0 ){
                /* If this match occurs on a column that is in the USING clause
                ** of a join, skip the search of the right table of the join
                ** to avoid a duplicate match there. */
                int k;
                for(k=0; k<pUsing->nId; k++){
                  if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){
                    pItem++;
                    i++;
                    break;
                  }
                }
              }
            }
            break;
          }
        }
      }

          no_such_func = 1;
        }else{
          wrong_num_args = 1;
        }
      }else{
        is_agg = pDef->xFunc==0;
      }
#ifndef SQLITE_OMIT_AUTHORIZER
#ifndef SQLITE_OMIT_AUTHORIZATION
      if( pDef ){
        auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
        if( auth!=SQLITE_OK ){
          if( auth==SQLITE_DENY ){
            sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
                                    pDef->zName);
            pNC->nErr++;

  NameContext *pNC = (NameContext *)pArg;
  Parse *pParse = pNC->pParse;
  SrcList *pSrcList = pNC->pSrcList;
  AggInfo *pAggInfo = pNC->pAggInfo;
  

  switch( pExpr->op ){
    case TK_AGG_COLUMN:
    case TK_COLUMN: {
      /* Check to see if the column is in one of the tables in the FROM
      ** clause of the aggregate query */
      if( pSrcList ){
        struct SrcList_item *pItem = pSrcList->a;
        for(i=0; i<pSrcList->nSrc; i++, pItem++){
          struct AggInfo_col *pCol;

typedef struct StringBuffer {
  int len;      /* length, not including null terminator */
  int alloced;  /* Space allocated for s[] */ 
  char *s;      /* Content of the string */
} StringBuffer;

void initStringBuffer(StringBuffer *sb){
static void initStringBuffer(StringBuffer *sb){
  sb->len = 0;
  sb->alloced = 100;
  sb->s = malloc(100);
  sb->s[0] = '\0';
}

void nappend(StringBuffer *sb, const char *zFrom, int nFrom){
static void nappend(StringBuffer *sb, const char *zFrom, int nFrom){
  if( sb->len + nFrom >= sb->alloced ){
    sb->alloced = sb->len + nFrom + 100;
    sb->s = realloc(sb->s, sb->alloced+1);
    if( sb->s==0 ){
      initStringBuffer(sb);
      return;
    }
  }
  memcpy(sb->s + sb->len, zFrom, nFrom);
  sb->len += nFrom;
  sb->s[sb->len] = 0;
}
void append(StringBuffer *sb, const char *zFrom){
static void append(StringBuffer *sb, const char *zFrom){
  nappend(sb, zFrom, strlen(zFrom));
}

/* We encode variable-length integers in little-endian order using seven bits
 * per byte as follows:
**
** KEY:

  rc = sqlite3_bind_int64(s, 1+v->nColumn, iRowid);
  if( rc!=SQLITE_OK ) return rc;

  return sql_single_step_statement(v, CONTENT_UPDATE_STMT, &s);
}

void freeStringArray(int nString, const char **pString){
static void freeStringArray(int nString, const char **pString){
  int i;

  for (i=0 ; i < nString ; ++i) {
    free((void *) pString[i]);
  }
  free((void *) pString);
}

** Examples:
**
**     "abc"   becomes   abc
**     'xyz'   becomes   xyz
**     [pqr]   becomes   pqr
**     `mno`   becomes   mno
*/
void dequoteString(char *z){
static void dequoteString(char *z){
  int quote;
  int i, j;
  if( z==0 ) return;
  quote = z[0];
  switch( quote ){
    case '\'':  break;
    case '"':   break;

**     output:     chinese simplifed mixed
**
** Another example:
**
**     input:      delimiters ( '[' , ']' , '...' )
**     output:     [ ] ...
*/
void tokenListToIdList(char **azIn){
static void tokenListToIdList(char **azIn){
  int i, j;
  if( azIn ){
    for(i=0, j=-1; azIn[i]; i++){
      if( isalnum(azIn[i][0]) || azIn[i][1] ){
        dequoteString(azIn[i]);
        if( j>=0 ){
          azIn[j] = azIn[i];

/*
** Find the first alphanumeric token in the string zIn.  Null-terminate
** this token.  Remove any quotation marks.  And return a pointer to
** the result.
*/
static char *firstToken(char *zIn, char **pzTail){
  int i, n, ttype;
  int n, ttype;
  i = 0;
  while(1){
    n = getToken(zIn, &ttype);
    if( ttype==TOKEN_SPACE ){
      zIn += n;
    }else if( ttype==TOKEN_EOF ){
      *pzTail = zIn;
      return 0;

  char **azContentColumn;  /* Column names for %_content */
  char **azTokenizer;      /* Name of tokenizer and its arguments */
} TableSpec;

/*
** Reclaim all of the memory used by a TableSpec
*/
void clearTableSpec(TableSpec *p) {
static void clearTableSpec(TableSpec *p) {
  free(p->azColumn);
  free(p->azContentColumn);
  free(p->azTokenizer);
}

/* Parse a CREATE VIRTUAL TABLE statement, which looks like this:
 *
 * CREATE VIRTUAL TABLE email
 *        USING fts1(subject, body, tokenize mytokenizer(myarg))
 *
 * We return parsed information in a TableSpec structure.
 * 
 */
int parseSpec(TableSpec *pSpec, int argc, const char *const*argv, char**pzErr){
  int i, j, n;
static int parseSpec(TableSpec *pSpec, int argc, const char *const*argv,
                     char**pzErr){
  int i, n;
  char *z, *zDummy;
  char **azArg;
  const char *zTokenizer = 0;    /* argv[] entry describing the tokenizer */

  assert( argc>=3 );
  /* Current interface:
  ** argv[0] - module name

  /* Identify the column names and the tokenizer and delimiter arguments
  ** in the argv[][] array.
  */
  pSpec->zName = azArg[2];
  pSpec->nColumn = 0;
  pSpec->azColumn = azArg;
  zTokenizer = "tokenize simple";
  for(i=3, j=0; i<argc; ++i){
  for(i=3; i<argc; ++i){
    if( startsWith(azArg[i],"tokenize") ){
      zTokenizer = azArg[i];
    }else{
      z = azArg[pSpec->nColumn] = firstToken(azArg[i], &zDummy);
      pSpec->nColumn++;
    }
  }

  clearTableSpec(&spec);
  return rc;
}

/* Decide how to handle an SQL query. */
static int fulltextBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
  int i;
  TRACE(("FTS1 BestIndex\n"));

  for(i=0; i<pInfo->nConstraint; ++i){
    const struct sqlite3_index_constraint *pConstraint;
    pConstraint = &pInfo->aConstraint[i];
    if( pConstraint->usable ) {
      if( pConstraint->iColumn==-1 &&
          pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){
        pInfo->idxNum = QUERY_ROWID;      /* lookup by rowid */
        TRACE(("FTS1 QUERY_ROWID\n"));
      } else if( pConstraint->iColumn>=0 &&
                 pConstraint->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
        /* full-text search */
        pInfo->idxNum = QUERY_FULLTEXT + pConstraint->iColumn;
        TRACE(("FTS1 QUERY_FULLTEXT %d\n", pConstraint->iColumn));
      } else continue;

      pInfo->aConstraintUsage[i].argvIndex = 1;
      pInfo->aConstraintUsage[i].omit = 1;

      /* An arbitrary value for now.
       * TODO: Perhaps rowid matches should be considered cheaper than
       * full-text searches. */
      pInfo->estimatedCost = 1.0;   

      return SQLITE_OK;
    }
  }
  pInfo->idxNum = QUERY_GENERIC;
  TRACE(("FTS1 BestIndex\n"));
  return SQLITE_OK;
}

static int fulltextDisconnect(sqlite3_vtab *pVTab){
  TRACE(("FTS1 Disconnect %p\n", pVTab));
  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
  return SQLITE_OK;
}

static int fulltextDestroy(sqlite3_vtab *pVTab){
  fulltext_vtab *v = (fulltext_vtab *)pVTab;
  int rc;

  TRACE(("FTS1 Destroy %p\n", pVTab));
  rc = sql_exec(v->db, v->zName,
                "drop table if exists %_content;"
                    "drop table %_content; drop table %_term");
                "drop table if exists %_term;"
                );
  if( rc!=SQLITE_OK ) return rc;

  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
  return SQLITE_OK;
}

static int fulltextOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){

** If idxNum==QUERY_ROWID then do a rowid lookup for a single entry
** in the %_content table.
**
** If idxNum>=QUERY_FULLTEXT then use the full text index.  The
** column on the left-hand side of the MATCH operator is column
** number idxNum-QUERY_FULLTEXT, 0 indexed.  argv[0] is the right-hand
** side of the MATCH operator.
*/
/* TODO(shess) Upgrade the cursor initialization and destruction to
** account for fulltextFilter() being called multiple times on the
** same cursor.  The current solution is very fragile.  Apply fix to
** fts2 as appropriate.
*/
static int fulltextFilter(
  sqlite3_vtab_cursor *pCursor,     /* The cursor used for this query */
  int idxNum, const char *idxStr,   /* Which indexing scheme to use */
  int argc, sqlite3_value **argv    /* Arguments for the indexing scheme */
){
  fulltext_cursor *c = (fulltext_cursor *) pCursor;
  fulltext_vtab *v = cursor_vtab(c);
  int rc;
  char *zSql;

  TRACE(("FTS1 Filter %p\n",pCursor));

  zSql = sqlite3_mprintf("select rowid, * from %%_content %s",
                          idxNum==QUERY_GENERIC ? "" : "where rowid=?");
  sqlite3_finalize(c->pStmt);
  rc = sql_prepare(v->db, v->zName, &c->pStmt, zSql);
  sqlite3_free(zSql);
  if( rc!=SQLITE_OK ) goto out;
  if( rc!=SQLITE_OK ) return rc;

  c->iCursorType = idxNum;
  switch( idxNum ){
    case QUERY_GENERIC:
      break;

    case QUERY_ROWID:
      rc = sqlite3_bind_int64(c->pStmt, 1, sqlite3_value_int64(argv[0]));
      if( rc!=SQLITE_OK ) goto out;
      if( rc!=SQLITE_OK ) return rc;
      break;

    default:   /* full-text search */
    {
      const char *zQuery = (const char *)sqlite3_value_text(argv[0]);
      DocList *pResult;
      assert( idxNum<=QUERY_FULLTEXT+v->nColumn);
      assert( argc==1 );
      queryClear(&c->q);
      rc = fulltextQuery(v, idxNum-QUERY_FULLTEXT, zQuery, -1, &pResult, &c->q);
      if( rc!=SQLITE_OK ) goto out;
      if( rc!=SQLITE_OK ) return rc;
      if( c->result.pDoclist!=NULL ) docListDelete(c->result.pDoclist);
      readerInit(&c->result, pResult);
      break;
    }
  }

  rc = fulltextNext(pCursor);
  return fulltextNext(pCursor);

out:
  return rc;
}

/* This is the xEof method of the virtual table.  The SQLite core
** calls this routine to find out if it has reached the end of
** a query's results set.
*/
static int fulltextEof(sqlite3_vtab_cursor *pCursor){

** Create a new tokenizer instance.
*/
static int porterCreate(
  int argc, const char * const *argv,
  sqlite3_tokenizer **ppTokenizer
){
  porter_tokenizer *t;
  int i;

for(i=0; i<argc; i++) printf("argv[%d] = %s\n", i, argv[i]);
  t = (porter_tokenizer *) calloc(sizeof(porter_tokenizer), 1);
  *ppTokenizer = &t->base;
  return SQLITE_OK;
}

/*
** Destroy a tokenizer

/*
** Characters that can be part of a token.  We assume any character
** whose value is greater than 0x80 (any UTF character) can be
** part of a token.  In other words, delimiters all must have
** values of 0x7f or lower.
*/
const char isIdChar[] = {
static const char isIdChar[] = {
/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
};

** This file contains the C functions that implement various SQL
** functions of SQLite.  
**
** There is only one exported symbol in this file - the function
** sqliteRegisterBuildinFunctions() found at the bottom of the file.
** All other code has file scope.
**
** $Id: func.c,v 1.26 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: func.c,v 1.27 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
/* #include <math.h> */
#include <stdlib.h>
#include <assert.h>
#include "vdbeInt.h"

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This is the implementation of generic hash-tables
** used in SQLite.
**
** $Id: hash.c,v 1.23 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: hash.c,v 1.24 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <assert.h>

/* Turn bulk memory into a hash table object by initializing the
** fields of the Hash structure.
**

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This is the header file for the generic hash-table implemenation
** used in SQLite.
**
** $Id: hash.h,v 1.23 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: hash.h,v 1.24 2007/01/10 14:50:46 rmsimpson Exp $
*/
#ifndef _SQLITE_HASH_H_
#define _SQLITE_HASH_H_

/* Forward declarations of structures. */
typedef struct Hash Hash;
typedef struct HashElem HashElem;

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that are called by the parser
** to handle INSERT statements in SQLite.
**
** $Id: insert.c,v 1.24 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: insert.c,v 1.25 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** Set P3 of the most recently inserted opcode to a column affinity
** string for index pIdx. A column affinity string has one character
** for each column in the table, according to the affinity of the column:

**
*************************************************************************
** Main file for the SQLite library.  The routines in this file
** implement the programmer interface to the library.  Routines in
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
** $Id: legacy.c,v 1.23 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: legacy.c,v 1.24 2007/01/10 14:50:46 rmsimpson Exp $
*/

#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>

/*

  ** sqlite3_libversion_number() to make sure they are dealing with
  ** a library that is new enough to support that API.
  *************************************************************************
  */
  sqlite3_overload_function,
};

/*
** The windows implementation of shared-library loaders
*/
#if defined(_WIN32) || defined(WIN32) || defined(__MINGW32__) || defined(__BORLANDC__)
# include <windows.h>
# define SQLITE_LIBRARY_TYPE     HANDLE
# define SQLITE_OPEN_LIBRARY(A)  LoadLibrary(A)
#ifdef _WIN32_WCE
# define SQLITE_FIND_SYMBOL(A,B) GetProcAddressA(A,B)
#else
# define SQLITE_FIND_SYMBOL(A,B) GetProcAddress(A,B)
#endif
# define SQLITE_CLOSE_LIBRARY(A) FreeLibrary(A)
#endif /* windows */

/*
** The unix implementation of shared-library loaders
*/
#if defined(HAVE_DLOPEN) && !defined(SQLITE_LIBRARY_TYPE)
# include <dlfcn.h>
# define SQLITE_LIBRARY_TYPE     void*
# define SQLITE_OPEN_LIBRARY(A)  dlopen(A, RTLD_NOW | RTLD_GLOBAL)
# define SQLITE_FIND_SYMBOL(A,B) dlsym(A,B)
# define SQLITE_CLOSE_LIBRARY(A) dlclose(A)
#endif

/*
** Attempt to load an SQLite extension library contained in the file
** zFile.  The entry point is zProc.  zProc may be 0 in which case a
** default entry point name (sqlite3_extension_init) is used.  Use
** of the default name is recommended.
**
** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
**
** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with 
** error message text.  The calling function should free this memory
** by calling sqlite3_free().
*/
int sqlite3_load_extension(
  sqlite3 *db,          /* Load the extension into this database connection */
  const char *zFile,    /* Name of the shared library containing extension */
  const char *zProc,    /* Entry point.  Use "sqlite3_extension_init" if 0 */
  char **pzErrMsg       /* Put error message here if not 0 */
){
#ifdef SQLITE_LIBRARY_TYPE
  SQLITE_LIBRARY_TYPE handle;
  void *handle;
  int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
  char *zErrmsg = 0;
  SQLITE_LIBRARY_TYPE *aHandle;
  void **aHandle;

#ifdef _WIN32_WCE
  WCHAR zWideFile[MAX_PATH];
  MultiByteToWideChar(CP_ACP, 0, zFile, -1, zWideFile, MAX_PATH);
#endif

  /* Ticket #1863.  To avoid a creating security problems for older
  ** applications that relink against newer versions of SQLite, the
  ** ability to run load_extension is turned off by default.  One
  ** must call sqlite3_enable_load_extension() to turn on extension
  ** loading.  Otherwise you get the following error.
  */
  if( (db->flags & SQLITE_LoadExtension)==0 ){
    if( pzErrMsg ){
      *pzErrMsg = sqlite3_mprintf("not authorized");
    }
    return SQLITE_ERROR;
  }

  if( zProc==0 ){
    zProc = "sqlite3_extension_init";
  }

#ifdef _WIN32_WCE
  handle = SQLITE_OPEN_LIBRARY(zWideFile);
#else
  handle = SQLITE_OPEN_LIBRARY(zFile);
  handle = sqlite3OsDlopen(zFile);
#endif
  if( handle==0 ){
    if( pzErrMsg ){
      *pzErrMsg = sqlite3_mprintf("unable to open shared library [%s]", zFile);
    }
    return SQLITE_ERROR;
  }
  xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
                   SQLITE_FIND_SYMBOL(handle, zProc);
                   sqlite3OsDlsym(handle, zProc);
  if( xInit==0 ){
    if( pzErrMsg ){
       *pzErrMsg = sqlite3_mprintf("no entry point [%s] in shared library [%s]",
                                   zProc, zFile);
    }
    SQLITE_CLOSE_LIBRARY(handle);
    sqlite3OsDlclose(handle);
    return SQLITE_ERROR;
  }else if( xInit(db, &zErrmsg, &sqlite3_apis) ){
    if( pzErrMsg ){
      *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
    }
    sqlite3_free(zErrmsg);
    SQLITE_CLOSE_LIBRARY(handle);
    sqlite3OsDlclose(handle);
    return SQLITE_ERROR;
  }

  /* Append the new shared library handle to the db->aExtension array. */
  db->nExtension++;
  aHandle = sqliteMalloc(sizeof(handle)*db->nExtension);
  if( aHandle==0 ){
    return SQLITE_NOMEM;
  }
  if( db->nExtension>0 ){
    memcpy(aHandle, db->aExtension, sizeof(handle)*(db->nExtension-1));
  }
  sqliteFree(db->aExtension);
  db->aExtension = aHandle;

  ((SQLITE_LIBRARY_TYPE*)db->aExtension)[db->nExtension-1] = handle;
  db->aExtension[db->nExtension-1] = handle;
  return SQLITE_OK;
#else
  if( pzErrMsg ){
    *pzErrMsg = sqlite3_mprintf("extension loading is disabled");
  }
  return SQLITE_ERROR;
#endif
}

/*
** Call this routine when the database connection is closing in order
** to clean up loaded extensions
*/
void sqlite3CloseExtensions(sqlite3 *db){
#ifdef SQLITE_LIBRARY_TYPE
  int i;
  for(i=0; i<db->nExtension; i++){
    SQLITE_CLOSE_LIBRARY(((SQLITE_LIBRARY_TYPE*)db->aExtension)[i]);
    sqlite3OsDlclose(db->aExtension[i]);
  }
  sqliteFree(db->aExtension);
#endif
}

/*
** Enable or disable extension loading.  Extension loading is disabled by
** default so as not to open security holes in older applications.
*/
int sqlite3_enable_load_extension(sqlite3 *db, int onoff){

**
*************************************************************************
** Main file for the SQLite library.  The routines in this file
** implement the programmer interface to the library.  Routines in
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
** $Id: main.c,v 1.25 2006/10/12 21:34:21 rmsimpson Exp $
** $Id: main.c,v 1.26 2007/01/10 14:50:46 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>

/*
** The following constant value is used by the SQLITE_BIGENDIAN and

    sqlite3RegisterBuiltinFunctions(db);
  }
  db->magic = SQLITE_MAGIC_OPEN;

  /* Load automatic extensions - extensions that have been registered
  ** using the sqlite3_automatic_extension() API.
  */
  sqlite3AutoLoadExtensions(db);
  (void)sqlite3AutoLoadExtensions(db);

#ifdef SQLITE_ENABLE_FTS1
  {
    extern int sqlite3Fts1Init(sqlite3*);
    sqlite3Fts1Init(db);
  }
#endif

#ifdef SQLITE_ENABLE_FTS2
  {
    extern int sqlite3Fts2Init(sqlite3*);
    sqlite3Fts2Init(db);
  }
#endif

opendb_out:
  if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
    sqlite3_close(db);
    db = 0;
  }
  *ppDb = db;

 /*  26 */ "String",
 /*  27 */ "RealAffinity",
 /*  28 */ "ParseSchema",
 /*  29 */ "VOpen",
 /*  30 */ "Close",
 /*  31 */ "CreateIndex",
 /*  32 */ "IsUnique",
 /*  33 */ "IdxIsNull",
 /*  34 */ "NotFound",
 /*  35 */ "Int64",
 /*  36 */ "MustBeInt",
 /*  37 */ "Halt",
 /*  38 */ "Rowid",
 /*  39 */ "IdxLT",
 /*  40 */ "AddImm",
 /*  41 */ "Statement",
 /*  42 */ "RowData",
 /*  43 */ "MemMax",
 /*  44 */ "Push",
 /*  45 */ "NotExists",
 /*  46 */ "MemIncr",
 /*  47 */ "Gosub",
 /*  48 */ "Integer",
 /*  49 */ "MemInt",
 /*  50 */ "Prev",
 /*  51 */ "VColumn",
 /*  52 */ "CreateTable",
 /*  53 */ "Last",
 /*  54 */ "IdxRowid",
 /*  55 */ "MakeIdxRec",
 /*  56 */ "ResetCount",
 /*  57 */ "FifoWrite",
 /*  58 */ "Callback",
 /*  59 */ "ContextPush",
 /*  60 */ "DropTrigger",
 /*  33 */ "NotFound",
 /*  34 */ "Int64",
 /*  35 */ "MustBeInt",
 /*  36 */ "Halt",
 /*  37 */ "Rowid",
 /*  38 */ "IdxLT",
 /*  39 */ "AddImm",
 /*  40 */ "Statement",
 /*  41 */ "RowData",
 /*  42 */ "MemMax",
 /*  43 */ "Push",
 /*  44 */ "NotExists",
 /*  45 */ "MemIncr",
 /*  46 */ "Gosub",
 /*  47 */ "Integer",
 /*  48 */ "MemInt",
 /*  49 */ "Prev",
 /*  50 */ "VColumn",
 /*  51 */ "CreateTable",
 /*  52 */ "Last",
 /*  53 */ "IdxRowid",
 /*  54 */ "MakeIdxRec",
 /*  55 */ "ResetCount",
 /*  56 */ "FifoWrite",
 /*  57 */ "Callback",
 /*  58 */ "ContextPush",
 /*  59 */ "DropTrigger",
 /*  60 */ "DropIndex",
 /*  61 */ "Or",
 /*  62 */ "And",
 /*  63 */ "DropIndex",
 /*  64 */ "IdxGE",
 /*  65 */ "IdxDelete",
 /*  63 */ "IdxGE",
 /*  64 */ "IdxDelete",
 /*  65 */ "Vacuum",
 /*  66 */ "IsNull",
 /*  67 */ "NotNull",
 /*  68 */ "Ne",
 /*  69 */ "Eq",
 /*  70 */ "Gt",
 /*  71 */ "Le",
 /*  72 */ "Lt",
 /*  73 */ "Ge",
 /*  74 */ "Vacuum",
 /*  74 */ "MoveLe",
 /*  75 */ "BitAnd",
 /*  76 */ "BitOr",
 /*  77 */ "ShiftLeft",
 /*  78 */ "ShiftRight",
 /*  79 */ "Add",
 /*  80 */ "Subtract",
 /*  81 */ "Multiply",
 /*  82 */ "Divide",
 /*  83 */ "Remainder",
 /*  84 */ "Concat",
 /*  85 */ "Negative",
 /*  86 */ "MoveLe",
 /*  86 */ "IfNot",
 /*  87 */ "BitNot",
 /*  88 */ "String8",
 /*  89 */ "IfNot",
 /*  90 */ "DropTable",
 /*  91 */ "MakeRecord",
 /*  92 */ "Delete",
 /*  93 */ "AggFinal",
 /*  94 */ "Dup",
 /*  95 */ "Goto",
 /*  96 */ "TableLock",
 /*  97 */ "FifoRead",
 /*  98 */ "Clear",
 /*  99 */ "IdxGT",
 /* 100 */ "MoveLt",
 /* 101 */ "VerifyCookie",
 /* 102 */ "AggStep",
 /* 103 */ "Pull",
 /* 104 */ "SetNumColumns",
 /* 105 */ "AbsValue",
 /* 106 */ "Transaction",
 /* 107 */ "VFilter",
 /* 108 */ "VDestroy",
 /* 109 */ "ContextPop",
 /* 110 */ "Next",
 /* 111 */ "IdxInsert",
 /* 112 */ "Distinct",
 /* 113 */ "Insert",
 /* 114 */ "Destroy",
 /* 115 */ "ReadCookie",
 /* 116 */ "ForceInt",
 /* 117 */ "LoadAnalysis",
 /* 118 */ "Explain",
 /* 119 */ "IfMemZero",
 /* 120 */ "OpenPseudo",
 /* 121 */ "OpenEphemeral",
 /* 122 */ "Null",
 /* 123 */ "Blob",
 /* 124 */ "MemStore",
 /* 125 */ "Rewind",
 /*  89 */ "DropTable",
 /*  90 */ "MakeRecord",
 /*  91 */ "Delete",
 /*  92 */ "AggFinal",
 /*  93 */ "Dup",
 /*  94 */ "Goto",
 /*  95 */ "TableLock",
 /*  96 */ "FifoRead",
 /*  97 */ "Clear",
 /*  98 */ "IdxGT",
 /*  99 */ "MoveLt",
 /* 100 */ "VerifyCookie",
 /* 101 */ "AggStep",
 /* 102 */ "Pull",
 /* 103 */ "SetNumColumns",
 /* 104 */ "AbsValue",
 /* 105 */ "Transaction",
 /* 106 */ "VFilter",
 /* 107 */ "VDestroy",
 /* 108 */ "ContextPop",
 /* 109 */ "Next",
 /* 110 */ "IdxInsert",
 /* 111 */ "Distinct",
 /* 112 */ "Insert",
 /* 113 */ "Destroy",
 /* 114 */ "ReadCookie",
 /* 115 */ "ForceInt",
 /* 116 */ "LoadAnalysis",
 /* 117 */ "Explain",
 /* 118 */ "IfMemZero",
 /* 119 */ "OpenPseudo",
 /* 120 */ "OpenEphemeral",
 /* 121 */ "Null",
 /* 122 */ "Blob",
 /* 123 */ "MemStore",
 /* 124 */ "Rewind",
 /* 125 */ "MoveGe",
 /* 126 */ "Real",
 /* 127 */ "HexBlob",
 /* 128 */ "MoveGe",
 /* 129 */ "VBegin",
 /* 130 */ "VUpdate",
 /* 131 */ "VCreate",
 /* 132 */ "MemMove",
 /* 133 */ "MemNull",
 /* 134 */ "Found",
 /* 135 */ "NullRow",
 /* 128 */ "VBegin",
 /* 129 */ "VUpdate",
 /* 130 */ "VCreate",
 /* 131 */ "MemMove",
 /* 132 */ "MemNull",
 /* 133 */ "Found",
 /* 134 */ "NullRow",
 /* 135 */ "NotUsed_135",
 /* 136 */ "NotUsed_136",
 /* 137 */ "NotUsed_137",
 /* 138 */ "NotUsed_138",
 /* 139 */ "ToText",
 /* 140 */ "ToBlob",
 /* 141 */ "ToNumeric",
 /* 142 */ "ToInt",

#define OP_String                              26
#define OP_RealAffinity                        27
#define OP_ParseSchema                         28
#define OP_VOpen                               29
#define OP_Close                               30
#define OP_CreateIndex                         31
#define OP_IsUnique                            32
#define OP_IdxIsNull                           33
#define OP_NotFound                            34
#define OP_Int64                               35
#define OP_MustBeInt                           36
#define OP_Halt                                37
#define OP_Rowid                               38
#define OP_IdxLT                               39
#define OP_AddImm                              40
#define OP_Statement                           41
#define OP_RowData                             42
#define OP_MemMax                              43
#define OP_Push                                44
#define OP_NotFound                            33
#define OP_Int64                               34
#define OP_MustBeInt                           35
#define OP_Halt                                36
#define OP_Rowid                               37
#define OP_IdxLT                               38
#define OP_AddImm                              39
#define OP_Statement                           40
#define OP_RowData                             41
#define OP_MemMax                              42
#define OP_Push                                43
#define OP_Or                                  61   /* same as TK_OR       */
#define OP_NotExists                           45
#define OP_MemIncr                             46
#define OP_Gosub                               47
#define OP_NotExists                           44
#define OP_MemIncr                             45
#define OP_Gosub                               46
#define OP_Divide                              82   /* same as TK_SLASH    */
#define OP_Integer                             48
#define OP_Integer                             47
#define OP_ToNumeric                          141   /* same as TK_TO_NUMERIC*/
#define OP_MemInt                              49
#define OP_Prev                                50
#define OP_MemInt                              48
#define OP_Prev                                49
#define OP_Concat                              84   /* same as TK_CONCAT   */
#define OP_BitAnd                              75   /* same as TK_BITAND   */
#define OP_VColumn                             51
#define OP_CreateTable                         52
#define OP_Last                                53
#define OP_VColumn                             50
#define OP_CreateTable                         51
#define OP_Last                                52
#define OP_IsNull                              66   /* same as TK_ISNULL   */
#define OP_IdxRowid                            54
#define OP_MakeIdxRec                          55
#define OP_IdxRowid                            53
#define OP_MakeIdxRec                          54
#define OP_ShiftRight                          78   /* same as TK_RSHIFT   */
#define OP_ResetCount                          56
#define OP_FifoWrite                           57
#define OP_Callback                            58
#define OP_ContextPush                         59
#define OP_DropTrigger                         60
#define OP_DropIndex                           63
#define OP_IdxGE                               64
#define OP_IdxDelete                           65
#define OP_Vacuum                              74
#define OP_MoveLe                              86
#define OP_IfNot                               89
#define OP_DropTable                           90
#define OP_MakeRecord                          91
#define OP_ResetCount                          55
#define OP_FifoWrite                           56
#define OP_Callback                            57
#define OP_ContextPush                         58
#define OP_DropTrigger                         59
#define OP_DropIndex                           60
#define OP_IdxGE                               63
#define OP_IdxDelete                           64
#define OP_Vacuum                              65
#define OP_MoveLe                              74
#define OP_IfNot                               86
#define OP_DropTable                           89
#define OP_MakeRecord                          90
#define OP_ToBlob                             140   /* same as TK_TO_BLOB  */
#define OP_Delete                              92
#define OP_AggFinal                            93
#define OP_Delete                              91
#define OP_AggFinal                            92
#define OP_ShiftLeft                           77   /* same as TK_LSHIFT   */
#define OP_Dup                                 94
#define OP_Goto                                95
#define OP_TableLock                           96
#define OP_FifoRead                            97
#define OP_Clear                               98
#define OP_IdxGT                               99
#define OP_MoveLt                             100
#define OP_Dup                                 93
#define OP_Goto                                94
#define OP_TableLock                           95
#define OP_FifoRead                            96
#define OP_Clear                               97
#define OP_IdxGT                               98
#define OP_MoveLt                              99
#define OP_Le                                  71   /* same as TK_LE       */
#define OP_VerifyCookie                       101
#define OP_AggStep                            102
#define OP_Pull                               103
#define OP_VerifyCookie                       100
#define OP_AggStep                            101
#define OP_Pull                               102
#define OP_ToText                             139   /* same as TK_TO_TEXT  */
#define OP_Not                                 16   /* same as TK_NOT      */
#define OP_ToReal                             143   /* same as TK_TO_REAL  */
#define OP_SetNumColumns                      104
#define OP_AbsValue                           105
#define OP_Transaction                        106
#define OP_VFilter                            107
#define OP_SetNumColumns                      103
#define OP_AbsValue                           104
#define OP_Transaction                        105
#define OP_VFilter                            106
#define OP_Negative                            85   /* same as TK_UMINUS   */
#define OP_Ne                                  68   /* same as TK_NE       */
#define OP_VDestroy                           108
#define OP_ContextPop                         109
#define OP_VDestroy                           107
#define OP_ContextPop                         108
#define OP_BitOr                               76   /* same as TK_BITOR    */
#define OP_Next                               110
#define OP_IdxInsert                          111
#define OP_Distinct                           112
#define OP_Next                               109
#define OP_IdxInsert                          110
#define OP_Distinct                           111
#define OP_Lt                                  72   /* same as TK_LT       */
#define OP_Insert                             113
#define OP_Destroy                            114
#define OP_ReadCookie                         115
#define OP_ForceInt                           116
#define OP_LoadAnalysis                       117
#define OP_Explain                            118
#define OP_IfMemZero                          119
#define OP_OpenPseudo                         120
#define OP_OpenEphemeral                      121
#define OP_Null                               122
#define OP_Blob                               123
#define OP_Insert                             112
#define OP_Destroy                            113
#define OP_ReadCookie                         114
#define OP_ForceInt                           115
#define OP_LoadAnalysis                       116
#define OP_Explain                            117
#define OP_IfMemZero                          118
#define OP_OpenPseudo                         119
#define OP_OpenEphemeral                      120
#define OP_Null                               121
#define OP_Blob                               122
#define OP_Add                                 79   /* same as TK_PLUS     */
#define OP_MemStore                           124
#define OP_Rewind                             125
#define OP_MoveGe                             128
#define OP_VBegin                             129
#define OP_VUpdate                            130
#define OP_MemStore                           123
#define OP_Rewind                             124
#define OP_MoveGe                             125
#define OP_VBegin                             128
#define OP_VUpdate                            129
#define OP_BitNot                              87   /* same as TK_BITNOT   */
#define OP_VCreate                            131
#define OP_MemMove                            132
#define OP_MemNull                            133
#define OP_Found                              134
#define OP_NullRow                            135
#define OP_VCreate                            130
#define OP_MemMove                            131
#define OP_MemNull                            132
#define OP_Found                              133
#define OP_NullRow                            134

/* The following opcode values are never used */
#define OP_NotUsed_135                        135
#define OP_NotUsed_136                        136
#define OP_NotUsed_137                        137
#define OP_NotUsed_138                        138

/* Opcodes that are guaranteed to never push a value onto the stack
** contain a 1 their corresponding position of the following mask
** set.  See the opcodeNoPush() function in vdbeaux.c  */
#define NOPUSH_MASK_0 0xeeb4
#define NOPUSH_MASK_1 0x796b
#define NOPUSH_MASK_2 0xfbb7
#define NOPUSH_MASK_3 0xff24
#define NOPUSH_MASK_2 0x7ddb
#define NOPUSH_MASK_3 0xff92
#define NOPUSH_MASK_4 0xffff
#define NOPUSH_MASK_5 0xb6ef
#define NOPUSH_MASK_6 0xfdfd
#define NOPUSH_MASK_7 0x33b3
#define NOPUSH_MASK_8 0xf8cf
#define NOPUSH_MASK_5 0xdaef
#define NOPUSH_MASK_6 0xfefe
#define NOPUSH_MASK_7 0x39d9
#define NOPUSH_MASK_8 0xf867
#define NOPUSH_MASK_9 0x0000

** Temporary files are named starting with this prefix followed by 16 random
** alphanumeric characters, and no file extension. They are stored in the
** OS's standard temporary file directory, and are deleted prior to exit.
** If sqlite is being embedded in another program, you may wish to change the
** prefix to reflect your program's name, so that if your program exits
** prematurely, old temporary files can be easily identified. This can be done
** using -DTEMP_FILE_PREFIX=myprefix_ on the compiler command line.
**
** 2006-10-31:  The default prefix used to be "sqlite_".  But then
** Mcafee started using SQLite in their anti-virus product and it
** started putting files with the "sqlite" name in the c:/temp folder.
** This annoyed many windows users.  Those users would then do a 
** Google search for "sqlite", find the telephone numbers of the
** developers and call to wake them up at night and complain.
** For this reason, the default name prefix is changed to be "sqlite" 
** spelled backwards.  So the temp files are still identified, but
** anybody smart enough to figure out the code is also likely smart
** enough to know that calling the developer will not help get rid
** of the file.
*/
#ifndef TEMP_FILE_PREFIX
# define TEMP_FILE_PREFIX "sqlite_"
# define TEMP_FILE_PREFIX "etilqs_"
#endif

/*
** Define the interfaces for Unix, Windows, and OS/2.
*/
#if OS_UNIX
#define sqlite3OsOpenReadWrite      sqlite3UnixOpenReadWrite

#define sqlite3OsLeaveMutex         sqlite3UnixLeaveMutex
#define sqlite3OsInMutex            sqlite3UnixInMutex
#define sqlite3OsThreadSpecificData sqlite3UnixThreadSpecificData
#define sqlite3OsMalloc             sqlite3GenericMalloc
#define sqlite3OsRealloc            sqlite3GenericRealloc
#define sqlite3OsFree               sqlite3GenericFree
#define sqlite3OsAllocationSize     sqlite3GenericAllocationSize
#define sqlite3OsDlopen             sqlite3UnixDlopen
#define sqlite3OsDlsym              sqlite3UnixDlsym
#define sqlite3OsDlclose            sqlite3UnixDlclose
#endif
#if OS_WIN
#define sqlite3OsOpenReadWrite      sqlite3WinOpenReadWrite
#define sqlite3OsOpenExclusive      sqlite3WinOpenExclusive
#define sqlite3OsOpenReadOnly       sqlite3WinOpenReadOnly
#define sqlite3OsDelete             sqlite3WinDelete
#define sqlite3OsFileExists         sqlite3WinFileExists

#define sqlite3OsLeaveMutex         sqlite3WinLeaveMutex
#define sqlite3OsInMutex            sqlite3WinInMutex
#define sqlite3OsThreadSpecificData sqlite3WinThreadSpecificData
#define sqlite3OsMalloc             sqlite3GenericMalloc
#define sqlite3OsRealloc            sqlite3GenericRealloc
#define sqlite3OsFree               sqlite3GenericFree
#define sqlite3OsAllocationSize     sqlite3GenericAllocationSize
#define sqlite3OsDlopen             sqlite3WinDlopen
#define sqlite3OsDlsym              sqlite3WinDlsym
#define sqlite3OsDlclose            sqlite3WinDlclose
#endif
#if OS_OS2
#define sqlite3OsOpenReadWrite      sqlite3Os2OpenReadWrite
#define sqlite3OsOpenExclusive      sqlite3Os2OpenExclusive
#define sqlite3OsOpenReadOnly       sqlite3Os2OpenReadOnly
#define sqlite3OsDelete             sqlite3Os2Delete
#define sqlite3OsFileExists         sqlite3Os2FileExists

#define sqlite3OsLeaveMutex         sqlite3Os2LeaveMutex
#define sqlite3OsInMutex            sqlite3Os2InMutex
#define sqlite3OsThreadSpecificData sqlite3Os2ThreadSpecificData
#define sqlite3OsMalloc             sqlite3GenericMalloc
#define sqlite3OsRealloc            sqlite3GenericRealloc
#define sqlite3OsFree               sqlite3GenericFree
#define sqlite3OsAllocationSize     sqlite3GenericAllocationSize
#define sqlite3OsDlopen             sqlite3Os2Dlopen
#define sqlite3OsDlsym              sqlite3Os2Dlsym
#define sqlite3OsDlclose            sqlite3Os2Dlclose
#endif




/*
** If using an alternative OS interface, then we must have an "os_other.h"

void sqlite3OsLeaveMutex(void);
int sqlite3OsInMutex(int);
ThreadData *sqlite3OsThreadSpecificData(int);
void *sqlite3OsMalloc(int);
void *sqlite3OsRealloc(void *, int);
void sqlite3OsFree(void *);
int sqlite3OsAllocationSize(void *);
void *sqlite3OsDlopen(const char*);
void *sqlite3OsDlsym(void*, const char*);
int sqlite3OsDlclose(void*);

/*
** If the SQLITE_ENABLE_REDEF_IO macro is defined, then the OS-layer
** interface routines are not called directly but are invoked using
** pointers to functions.  This allows the implementation of various
** OS-layer interface routines to be modified at run-time.  There are
** obscure but legitimate reasons for wanting to do this.  But for

  int (*xInMutex)(int);
  ThreadData *(*xThreadSpecificData)(int);

  void *(*xMalloc)(int);
  void *(*xRealloc)(void *, int);
  void (*xFree)(void *);
  int (*xAllocationSize)(void *);

  void *(*xDlopen)(const char*);
  void *(*xDlsym)(void*, const char*);
  int (*xDlclose)(void*);
};

/* Macro used to comment out routines that do not exists when there is
** no disk I/O 
** no disk I/O or extension loading
*/
#ifdef SQLITE_OMIT_DISKIO
# define IF_DISKIO(X)  0
#else
# define IF_DISKIO(X)  X
#endif
#ifdef SQLITE_OMIT_LOAD_EXTENSION
# define IF_DLOPEN(X)  0
#else
# define IF_DLOPEN(X)  X
#endif


#ifdef _SQLITE_OS_C_
  /*
  ** The os.c file implements the global virtual function table.
  */
  struct sqlite3OsVtbl sqlite3Os = {
    IF_DISKIO( sqlite3OsOpenReadWrite ),

    sqlite3OsEnterMutex,
    sqlite3OsLeaveMutex,
    sqlite3OsInMutex,
    sqlite3OsThreadSpecificData,
    sqlite3OsMalloc,
    sqlite3OsRealloc,
    sqlite3OsFree,
    sqlite3OsAllocationSize
    sqlite3OsAllocationSize,
    IF_DLOPEN( sqlite3OsDlopen ),
    IF_DLOPEN( sqlite3OsDlsym ),
    IF_DLOPEN( sqlite3OsDlclose ),
  };
#else
  /*
  ** Files other than os.c just reference the global virtual function table. 
  */
  extern struct sqlite3OsVtbl sqlite3Os;
#endif /* _SQLITE_OS_C_ */

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
******************************************************************************
**
** This file contains code that is specific to OS/2.
*/

#if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY)
/* os2safe.h has to be included before os2.h, needed for high mem */
#include <os2safe.h>
#endif

#include "sqliteInt.h"
#include "os.h"

#if OS_OS2

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

*/
int os2Read( OsFile *id, void *pBuf, int amt ){
  ULONG got;
  assert( id!=0 );
  SimulateIOError( return SQLITE_IOERR );
  TRACE3( "READ %d lock=%d\n", ((os2File*)id)->h, ((os2File*)id)->locktype );
  DosRead( ((os2File*)id)->h, pBuf, amt, &got );
  return (got == (ULONG)amt) ? SQLITE_OK : SQLITE_IOERR;
  return (got == (ULONG)amt) ? SQLITE_OK : SQLITE_IOERR_SHORT_READ;
}

/*
** Write data from a buffer into a file.  Return SQLITE_OK on success
** or some other error code on failure.
*/
int os2Write( OsFile *id, const void *pBuf, int amt ){

}

#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************
** Everything above deals with file I/O.  Everything that follows deals
** with other miscellanous aspects of the operating system interface
****************************************************************************/

#ifndef SQLITE_OMIT_LOAD_EXTENSION
/*
** Interfaces for opening a shared library, finding entry points
** within the shared library, and closing the shared library.
*/
void *sqlite3Os2Dlopen(const char *zFilename){
  return 0;
}
void *sqlite3Os2Dlsym(void *pHandle, const char *zSymbol){
  return 0;
}
int sqlite3Os2Dlclose(void *pHandle){
  return 0;
}
#endif /* SQLITE_OMIT_LOAD_EXTENSION */


/*
** Get information to seed the random number generator.  The seed
** is written into the buffer zBuf[256].  The calling function must
** supply a sufficiently large buffer.
*/
int sqlite3Os2RandomSeed( char *zBuf ){

  assert( id );
  TIMER_START;
  got = seekAndRead((unixFile*)id, pBuf, amt);
  TIMER_END;
  TRACE5("READ    %-3d %5d %7d %d\n", ((unixFile*)id)->h, got,
          last_page, TIMER_ELAPSED);
  SEEK(0);
  SimulateIOError( got=0 );
  SimulateIOError( got = -1 );
  if( got==amt ){
    return SQLITE_OK;
  }else if( got<0 ){
    return SQLITE_IOERR_READ;
  }else{
    memset(&((char*)pBuf)[got], 0, amt-got);
    return SQLITE_IOERR_SHORT_READ;
  }
}

/*
** Seek to the offset in id->offset then read cnt bytes into pBuf.
** Return the number of bytes actually read.  Update the offset.

 */
static int allocateUnixFile(
  int h,                  /* Open file descriptor of file being opened */
  OsFile **pId,           /* Write completed initialization here */
  const char *zFilename,  /* Name of the file being opened */
  int delFlag             /* Delete-on-or-before-close flag */
){
  sqlite3LockingStyle lockStyle;
  sqlite3LockingStyle lockingStyle;
  unixFile *pNew;
  unixFile f;
  int rc;

  lockingStyle = sqlite3DetectLockingStyle(zFilename, f.h);
  lockingStyle = sqlite3DetectLockingStyle(zFilename, h);
  if ( lockingStyle == posixLockingStyle ) {
    sqlite3OsEnterMutex();
    rc = findLockInfo(h, &f.pLock, &f.pOpen);
    sqlite3OsLeaveMutex();
    if( rc ){
      close(h);
      unlink(zFilename);

    releaseLockInfo(f.pLock);
    releaseOpenCnt(f.pOpen);
    sqlite3OsLeaveMutex();
    *pId = 0;
    return SQLITE_NOMEM;
  }else{
    *pNew = f;
    switch(lockStyle) {
    switch(lockingStyle) {
      case afpLockingStyle:
        /* afp locking uses the file path so it needs to be included in
        ** the afpLockingContext */
        pNew->pMethod = &sqlite3AFPLockingUnixIoMethod;
        pNew->lockingContext = 
          sqlite3ThreadSafeMalloc(sizeof(afpLockingContext));
        ((afpLockingContext *)pNew->lockingContext)->filePath = 

#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************
** Everything above deals with file I/O.  Everything that follows deals
** with other miscellanous aspects of the operating system interface
****************************************************************************/


#ifndef SQLITE_OMIT_LOAD_EXTENSION
/*
** Interfaces for opening a shared library, finding entry points
** within the shared library, and closing the shared library.
*/
#include <dlfcn.h>
void *sqlite3UnixDlopen(const char *zFilename){
  return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
}
void *sqlite3UnixDlsym(void *pHandle, const char *zSymbol){
  return dlsym(pHandle, zSymbol);
}
int sqlite3UnixDlclose(void *pHandle){
  return dlclose(pHandle);
}
#endif /* SQLITE_OMIT_LOAD_EXTENSION */

/*
** Get information to seed the random number generator.  The seed
** is written into the buffer zBuf[256].  The calling function must
** supply a sufficiently large buffer.
*/
int sqlite3UnixRandomSeed(char *zBuf){
  /* We have to initialize zBuf to prevent valgrind from reporting

      sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
    }
    return sqlite3_os_type==2;
  }
#endif /* OS_WINCE */

/*
** Convert a UTF-8 string to UTF-32.  Space to hold the returned string
** is obtained from sqliteMalloc.
** Convert a UTF-8 string to microsoft unicode (UTF-16?). 
**
** Space to hold the returned string is obtained from sqliteMalloc.
*/
static WCHAR *utf8ToUnicode(const char *zFilename){
  int nChar;
  WCHAR *zWideFilename;

  if( !isNT() ){
    return 0;
  }
  nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
  zWideFilename = sqliteMalloc( nChar*sizeof(zWideFilename[0]) );
  if( zWideFilename==0 ){
    return 0;
  }
  nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
  if( nChar==0 ){
    sqliteFree(zWideFilename);
    zWideFilename = 0;
  }
  return zWideFilename;
}

/*
** Convert UTF-32 to UTF-8.  Space to hold the returned string is
** Convert microsoft unicode to UTF-8.  Space to hold the returned string is
** obtained from sqliteMalloc().
*/
static char *unicodeToUtf8(const WCHAR *zWideFilename){
  int nByte;
  char *zFilename;

  nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
  zFilename = sqliteMalloc( nByte );
  if( zFilename==0 ){
    return 0;
  }
  nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
                              0, 0);
  if( nByte == 0 ){
    sqliteFree(zFilename);
    zFilename = 0;
  }
  return zFilename;
}

/*
** Convert an ansi string to microsoft unicode, based on the
** current codepage settings for file apis.
** 
** Space to hold the returned string is obtained
** from sqliteMalloc.
*/
static WCHAR *mbcsToUnicode(const char *zFilename){
  int nByte;
  WCHAR *zMbcsFilename;
  int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

  nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
  zMbcsFilename = sqliteMalloc( nByte*sizeof(zMbcsFilename[0]) );
  if( zMbcsFilename==0 ){
    return 0;
  }
  nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
  if( nByte==0 ){
    sqliteFree(zMbcsFilename);
    zMbcsFilename = 0;
  }
  return zMbcsFilename;
}

/*
** Convert microsoft unicode to multibyte character string, based on the
** user's Ansi codepage.
**
** Space to hold the returned string is obtained from
** sqliteMalloc().
*/
static char *unicodeToMbcs(const WCHAR *zWideFilename){
  int nByte;
  char *zFilename;
  int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

  nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
  zFilename = sqliteMalloc( nByte );
  if( zFilename==0 ){
    return 0;
  }
  nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
                              0, 0);
  if( nByte == 0 ){
    sqliteFree(zFilename);
    zFilename = 0;
  }
  return zFilename;
}

/*
** Convert multibyte character string to UTF-8.  Space to hold the
** returned string is obtained from sqliteMalloc().
*/
static char *mbcsToUtf8(const char *zFilename){
  char *zFilenameUtf8;
  WCHAR *zTmpWide;

  zTmpWide = mbcsToUnicode(zFilename);
  if( zTmpWide==0 ){
    return 0;
  }
  zFilenameUtf8 = unicodeToUtf8(zTmpWide);
  sqliteFree(zTmpWide);
  return zFilenameUtf8;
}

/*
** Convert UTF-8 to multibyte character string.  Space to hold the 
** returned string is obtained from sqliteMalloc().
*/
static char *utf8ToMbcs(const char *zFilename){
  char *zFilenameMbcs;
  WCHAR *zTmpWide;

  zTmpWide = utf8ToUnicode(zFilename);
  if( zTmpWide==0 ){
    return 0;
  }
  zFilenameMbcs = unicodeToMbcs(zTmpWide);
  sqliteFree(zTmpWide);
  return zFilenameMbcs;
}

#if OS_WINCE
/*************************************************************************
** This section contains code for WinCE only.
*/
/*
** WindowsCE does not have a localtime() function.  So create a

  }
  return FALSE;
}
/*
** End of the special code for wince
*****************************************************************************/
#endif /* OS_WINCE */

/*
** Convert a UTF-8 filename into whatever form the underlying
** operating system wants filenames in.  Space to hold the result
** is obtained from sqliteMalloc and must be freed by the calling
** function.
*/
static void *convertUtf8Filename(const char *zFilename){
  void *zConverted = 0;
  if( isNT() ){
    zConverted = utf8ToUnicode(zFilename);
  }else{
    zConverted = utf8ToMbcs(zFilename);
  }
  /* caller will handle out of memory */
  return zConverted;
}

/*
** Delete the named file.
**
** Note that windows does not allow a file to be deleted if some other
** process has it open.  Sometimes a virus scanner or indexing program
** will open a journal file shortly after it is created in order to do
** whatever it is it does.  While this other process is holding the
** file open, we will be unable to delete it.  To work around this
** problem, we delay 100 milliseconds and try to delete again.  Up
** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
** up and returning an error.
*/
#define MX_DELETION_ATTEMPTS 3
int sqlite3WinDelete(const char *zFilename){
  WCHAR *zWide = utf8ToUnicode(zFilename);
  int cnt = 0;
  int rc;
  void *zConverted = convertUtf8Filename(zFilename);
  if( zConverted==0 ){
    return SQLITE_NOMEM;
  }
  if( zWide ){
  if( isNT() ){
    do{
      rc = DeleteFileW(zWide);
    }while( rc==0 && GetFileAttributesW(zWide)!=0xffffffff 
      rc = DeleteFileW(zConverted);
    }while( rc==0 && GetFileAttributesW(zConverted)!=0xffffffff 
            && cnt++ < MX_DELETION_ATTEMPTS && (Sleep(100), 1) );
    sqliteFree(zWide);
  }else{
#if OS_WINCE
    return SQLITE_NOMEM;
#else
    do{
      rc = DeleteFileA(zFilename);
    }while( rc==0 && GetFileAttributesA(zFilename)!=0xffffffff
      rc = DeleteFileA(zConverted);
    }while( rc==0 && GetFileAttributesA(zConverted)!=0xffffffff
            && cnt++ < MX_DELETION_ATTEMPTS && (Sleep(100), 1) );
#endif
  }
  sqliteFree(zConverted);
  TRACE2("DELETE \"%s\"\n", zFilename);
  return rc!=0 ? SQLITE_OK : SQLITE_IOERR;
}

/*
** Return TRUE if the named file exists.
*/
int sqlite3WinFileExists(const char *zFilename){
  int exists = 0;
  WCHAR *zWide = utf8ToUnicode(zFilename);
  if( zWide ){
    exists = GetFileAttributesW(zWide) != 0xffffffff;
  void *zConverted = convertUtf8Filename(zFilename);
  if( zConverted==0 ){
    return SQLITE_NOMEM;
  }
  if( isNT() ){
    exists = GetFileAttributesW((WCHAR*)zConverted) != 0xffffffff;
    sqliteFree(zWide);
  }else{
#if OS_WINCE
    return SQLITE_NOMEM;
#else
    exists = GetFileAttributesA(zFilename) != 0xffffffff;
    exists = GetFileAttributesA((char*)zConverted) != 0xffffffff;
#endif
  }
  sqliteFree(zConverted);
  return exists;
}

/* Forward declaration */
static int allocateWinFile(winFile *pInit, OsFile **pId);

/*

int sqlite3WinOpenReadWrite(
  const char *zFilename,
  OsFile **pId,
  int *pReadonly
){
  winFile f;
  HANDLE h;
  WCHAR *zWide = utf8ToUnicode(zFilename);
  void *zConverted = convertUtf8Filename(zFilename);
  if( zConverted==0 ){
    return SQLITE_NOMEM;
  }
  assert( *pId==0 );
  if( zWide ){
    h = CreateFileW(zWide,

  if( isNT() ){
    h = CreateFileW((WCHAR*)zConverted,
       GENERIC_READ | GENERIC_WRITE,
       FILE_SHARE_READ | FILE_SHARE_WRITE,
       NULL,
       OPEN_ALWAYS,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
       NULL
    );
    if( h==INVALID_HANDLE_VALUE ){
      h = CreateFileW(zWide,
      h = CreateFileW((WCHAR*)zConverted,
         GENERIC_READ,
         FILE_SHARE_READ | FILE_SHARE_WRITE,
         NULL,
         OPEN_ALWAYS,
         FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
         NULL
      );
      if( h==INVALID_HANDLE_VALUE ){
        sqliteFree(zWide);
        sqliteFree(zConverted);
        return SQLITE_CANTOPEN;
      }
      *pReadonly = 1;
    }else{
      *pReadonly = 0;
    }
#if OS_WINCE
    if (!winceCreateLock(zFilename, &f)){
      CloseHandle(h);
      sqliteFree(zWide);
      sqliteFree(zConverted);
      return SQLITE_CANTOPEN;
    }
#endif
    sqliteFree(zWide);
  }else{
#if OS_WINCE
    return SQLITE_NOMEM;
#else
    h = CreateFileA(zFilename,
    h = CreateFileA((char*)zConverted,
       GENERIC_READ | GENERIC_WRITE,
       FILE_SHARE_READ | FILE_SHARE_WRITE,
       NULL,
       OPEN_ALWAYS,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
       NULL
    );
    if( h==INVALID_HANDLE_VALUE ){
      h = CreateFileA(zFilename,
      h = CreateFileA((char*)zConverted,
         GENERIC_READ,
         FILE_SHARE_READ | FILE_SHARE_WRITE,
         NULL,
         OPEN_ALWAYS,
         FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
         NULL
      );
      if( h==INVALID_HANDLE_VALUE ){
        sqliteFree(zConverted);
        return SQLITE_CANTOPEN;
      }
      *pReadonly = 1;
    }else{
      *pReadonly = 0;
    }
#endif /* OS_WINCE */
  }

  sqliteFree(zConverted);

  f.h = h;
#if OS_WINCE
  f.zDeleteOnClose = 0;
#endif
  TRACE3("OPEN R/W %d \"%s\"\n", h, zFilename);
  return allocateWinFile(&f, pId);
}

** To work around this bug, we pause for 100 milliseconds and attempt
** a second open after the first one fails.  The whole operation only
** fails if both open attempts are unsuccessful.
*/
int sqlite3WinOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){
  winFile f;
  HANDLE h;
  int fileflags;
  WCHAR *zWide = utf8ToUnicode(zFilename);
  DWORD fileflags;
  void *zConverted = convertUtf8Filename(zFilename);
  if( zConverted==0 ){
    return SQLITE_NOMEM;
  }
  assert( *pId == 0 );
  fileflags = FILE_FLAG_RANDOM_ACCESS;
#if !OS_WINCE
  if( delFlag ){
    fileflags |= FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE;
  }
#endif
  if( zWide ){
  if( isNT() ){
    int cnt = 0;
    do{
      h = CreateFileW(zWide,
      h = CreateFileW((WCHAR*)zConverted,
         GENERIC_READ | GENERIC_WRITE,
         0,
         NULL,
         CREATE_ALWAYS,
         fileflags,
         NULL
      );
    }while( h==INVALID_HANDLE_VALUE && cnt++ < 2 && (Sleep(100), 1) );
    sqliteFree(zWide);
  }else{
#if OS_WINCE
    return SQLITE_NOMEM;
#else
    int cnt = 0;
    do{
      h = CreateFileA(zFilename,
      h = CreateFileA((char*)zConverted,
        GENERIC_READ | GENERIC_WRITE,
        0,
        NULL,
        CREATE_ALWAYS,
        fileflags,
        NULL
      );
    }while( h==INVALID_HANDLE_VALUE && cnt++ < 2 && (Sleep(100), 1) );
#endif /* OS_WINCE */
  }
#if OS_WINCE
  if( delFlag && h!=INVALID_HANDLE_VALUE ){
    f.zDeleteOnClose = zConverted;
    zConverted = 0;
  }
  f.hMutex = NULL;
#endif
  sqliteFree(zConverted);
  if( h==INVALID_HANDLE_VALUE ){
    return SQLITE_CANTOPEN;
  }
  f.h = h;
#if OS_WINCE
  f.zDeleteOnClose = delFlag ? utf8ToUnicode(zFilename) : 0;
  f.hMutex = NULL;
#endif
  TRACE3("OPEN EX %d \"%s\"\n", h, zFilename);
  return allocateWinFile(&f, pId);
}

/*
** Attempt to open a new file for read-only access.
**
** On success, write the file handle into *id and return SQLITE_OK.
**
** On failure, return SQLITE_CANTOPEN.
*/
int sqlite3WinOpenReadOnly(const char *zFilename, OsFile **pId){
  winFile f;
  HANDLE h;
  WCHAR *zWide = utf8ToUnicode(zFilename);
  void *zConverted = convertUtf8Filename(zFilename);
  if( zConverted==0 ){
    return SQLITE_NOMEM;
  }
  assert( *pId==0 );
  if( zWide ){
    h = CreateFileW(zWide,
  if( isNT() ){
    h = CreateFileW((WCHAR*)zConverted,
       GENERIC_READ,
       0,
       NULL,
       OPEN_EXISTING,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
       NULL
    );
    sqliteFree(zWide);
  }else{
#if OS_WINCE
    return SQLITE_NOMEM;
#else
    h = CreateFileA(zFilename,
    h = CreateFileA((char*)zConverted,
       GENERIC_READ,
       0,
       NULL,
       OPEN_EXISTING,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
       NULL
    );
#endif
  }
  sqliteFree(zConverted);
  if( h==INVALID_HANDLE_VALUE ){
    return SQLITE_CANTOPEN;
  }
  f.h = h;
#if OS_WINCE
  f.zDeleteOnClose = 0;
  f.hMutex = NULL;

    WCHAR zWidePath[SQLITE_TEMPNAME_SIZE];
    GetTempPathW(SQLITE_TEMPNAME_SIZE-30, zWidePath);
    zMulti = unicodeToUtf8(zWidePath);
    if( zMulti ){
      strncpy(zTempPath, zMulti, SQLITE_TEMPNAME_SIZE-30);
      zTempPath[SQLITE_TEMPNAME_SIZE-30] = 0;
      sqliteFree(zMulti);
    }else{
      return SQLITE_NOMEM;
    }
  }else{
    char *zUtf8;
    char zMbcsPath[SQLITE_TEMPNAME_SIZE];
    GetTempPathA(SQLITE_TEMPNAME_SIZE-30, zTempPath);
    GetTempPathA(SQLITE_TEMPNAME_SIZE-30, zMbcsPath);
    zUtf8 = mbcsToUtf8(zMbcsPath);
    if( zUtf8 ){
      strncpy(zTempPath, zUtf8, SQLITE_TEMPNAME_SIZE-30);
      zTempPath[SQLITE_TEMPNAME_SIZE-30] = 0;
      sqliteFree(zUtf8);
    }else{
      return SQLITE_NOMEM;
    }
  }
  for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
  zTempPath[i] = 0;
  for(;;){
    sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zTempPath);
    j = strlen(zBuf);
    sqlite3Randomness(15, &zBuf[j]);

** 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 winRead(OsFile *id, void *pBuf, int amt){
  DWORD got;
  assert( id!=0 );
  SimulateIOError(return SQLITE_IOERR);
  SimulateIOError(return SQLITE_IOERR_READ);
  TRACE3("READ %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype);
  if( !ReadFile(((winFile*)id)->h, pBuf, amt, &got, 0) ){
    got = 0;
    return SQLITE_IOERR_READ;
  }
  if( got==(DWORD)amt ){
    return SQLITE_OK;
  }else{
    memset(&((char*)pBuf)[got], 0, amt-got);
    return SQLITE_IOERR;
    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 winWrite(OsFile *id, const void *pBuf, int amt){
  int rc = 0;
  DWORD wrote;
  assert( id!=0 );
  SimulateIOError(return SQLITE_IOERR);
  SimulateIOError(return SQLITE_IOERR_READ);
  SimulateDiskfullError(return SQLITE_FULL);
  TRACE3("WRITE %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype);
  assert( amt>0 );
  while( amt>0 && (rc = WriteFile(((winFile*)id)->h, pBuf, amt, &wrote, 0))!=0
         && wrote>0 ){
    amt -= wrote;
    pBuf = &((char*)pBuf)[wrote];

}

/*
** Sync the directory zDirname. This is a no-op on operating systems other
** than UNIX.
*/
int sqlite3WinSyncDirectory(const char *zDirname){
  SimulateIOError(return SQLITE_IOERR);
  SimulateIOError(return SQLITE_IOERR_READ);
  return SQLITE_OK;
}

/*
** Truncate an open file to a specified size
*/
static int winTruncate(OsFile *id, i64 nByte){
  LONG upperBits = nByte>>32;
  assert( id!=0 );
  TRACE3("TRUNCATE %d %lld\n", ((winFile*)id)->h, nByte);
  SimulateIOError(return SQLITE_IOERR);
  SimulateIOError(return SQLITE_IOERR_TRUNCATE);
  SetFilePointer(((winFile*)id)->h, nByte, &upperBits, FILE_BEGIN);
  SetEndOfFile(((winFile*)id)->h);
  return SQLITE_OK;
}

/*
** Determine the current size of a file in bytes
*/
static int winFileSize(OsFile *id, i64 *pSize){
  DWORD upperBits, lowerBits;
  assert( id!=0 );
  SimulateIOError(return SQLITE_IOERR);
  SimulateIOError(return SQLITE_IOERR_FSTAT);
  lowerBits = GetFileSize(((winFile*)id)->h, &upperBits);
  *pSize = (((i64)upperBits)<<32) + lowerBits;
  return SQLITE_OK;
}

/*
** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.

#ifndef SQLITE_OMIT_PAGER_PRAGMAS
/*
** Check that a given pathname is a directory and is writable 
**
*/
int sqlite3WinIsDirWritable(char *zDirname){
  int fileAttr;
  WCHAR *zWide;
  void *zConverted;
  if( zDirname==0 ) return 0;
  if( !isNT() && strlen(zDirname)>MAX_PATH ) return 0;
  zWide = utf8ToUnicode(zDirname);
  if( zWide ){
    fileAttr = GetFileAttributesW(zWide);

  zConverted = convertUtf8Filename(zDirname);
  if( zConverted==0 ){
    return SQLITE_NOMEM;
  }
  if( isNT() ){
    fileAttr = GetFileAttributesW((WCHAR*)zConverted);
    sqliteFree(zWide);
  }else{
#if OS_WINCE
    return 0;
#else
    fileAttr = GetFileAttributesA(zDirname);
    fileAttr = GetFileAttributesA((char*)zConverted);
#endif
  }
  sqliteFree(zConverted);
  if( fileAttr == 0xffffffff ) return 0;
  if( (fileAttr & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY ){
    return 0;
  }
  return 1;
}
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */

          pFile->locktype, pFile->sharedLockByte);
  type = pFile->locktype;
  if( type>=EXCLUSIVE_LOCK ){
    UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
    if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
      /* This should never happen.  We should always be able to
      ** reacquire the read lock */
      rc = SQLITE_IOERR;
      rc = SQLITE_IOERR_UNLOCK;
    }
  }
  if( type>=RESERVED_LOCK ){
    UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
  }
  if( locktype==NO_LOCK && type>=SHARED_LOCK ){
    unlockReadLock(pFile);

  zFull = sqliteMalloc( nByte );
  if( zFull==0 ) return 0;
  if( cygwin_conv_to_full_win32_path(zRelative, zFull) ) return 0;
#elif OS_WINCE
  /* WinCE has no concept of a relative pathname, or so I am told. */
  zFull = sqliteStrDup(zRelative);
#else
  char *zNotUsed;
  WCHAR *zWide;
  int nByte;
  void *zConverted;
  zWide = utf8ToUnicode(zRelative);
  if( zWide ){
    WCHAR *zTemp, *zNotUsedW;
    nByte = GetFullPathNameW(zWide, 0, 0, &zNotUsedW) + 1;
  zConverted = convertUtf8Filename(zRelative);
  if( isNT() ){
    WCHAR *zTemp;
    nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
    zTemp = sqliteMalloc( nByte*sizeof(zTemp[0]) );
    if( zTemp==0 ) return 0;
    GetFullPathNameW(zWide, nByte, zTemp, &zNotUsedW);
    sqliteFree(zWide);
    if( zTemp==0 ){
      sqliteFree(zConverted);
      return 0;
    }
    GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
    sqliteFree(zConverted);
    zFull = unicodeToUtf8(zTemp);
    sqliteFree(zTemp);
  }else{
    char *zTemp;
    nByte = GetFullPathNameA(zRelative, 0, 0, &zNotUsed) + 1;
    zFull = sqliteMalloc( nByte*sizeof(zFull[0]) );
    if( zFull==0 ) return 0;
    GetFullPathNameA(zRelative, nByte, zFull, &zNotUsed);
    nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
    zTemp = sqliteMalloc( nByte*sizeof(zTemp[0]) );
    if( zTemp==0 ){
      sqliteFree(zConverted);
      return 0;
    }
    GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
    sqliteFree(zConverted);
    zFull = mbcsToUtf8(zTemp);
    sqliteFree(zTemp);
  }
#endif
  return zFull;
}

/*
** The fullSync option is meaningless on windows.   This is a no-op.

#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************
** Everything above deals with file I/O.  Everything that follows deals
** with other miscellanous aspects of the operating system interface
****************************************************************************/

#if !defined(SQLITE_OMIT_LOAD_EXTENSION)
/*
** Interfaces for opening a shared library, finding entry points
** within the shared library, and closing the shared library.
*/
void *sqlite3WinDlopen(const char *zFilename){
  HANDLE h;
  void *zConverted = convertUtf8Filename(zFilename);
  if( zConverted==0 ){
    return 0;
  }
  if( isNT() ){
    h = LoadLibraryW((WCHAR*)zConverted);
  }else{
#if OS_WINCE
    return 0;
#else
    h = LoadLibraryA((char*)zConverted);
#endif
  }
  sqliteFree(zConverted);
  return (void*)h;
  
}
void *sqlite3WinDlsym(void *pHandle, const char *zSymbol){
#if OS_WINCE
  /* The GetProcAddressA() routine is only available on wince. */
  return GetProcAddressA((HANDLE)pHandle, zSymbol);
#else
  /* All other windows platforms expect GetProcAddress() to take
  ** an Ansi string regardless of the _UNICODE setting */
  return GetProcAddress((HANDLE)pHandle, zSymbol);
#endif
}
int sqlite3WinDlclose(void *pHandle){
  return FreeLibrary((HANDLE)pHandle);
}
#endif /* !SQLITE_OMIT_LOAD_EXTENSION */

/*
** Get information to seed the random number generator.  The seed
** is written into the buffer zBuf[256].  The calling function must
** supply a sufficiently large buffer.
*/
int sqlite3WinRandomSeed(char *zBuf){

** The pager is used to access a database disk file.  It implements
** atomic commit and rollback through the use of a journal file that
** is separate from the database file.  The pager also implements file
** locking to prevent two processes from writing the same database
** file simultaneously, or one process from reading the database while
** another is writing.
**
** @(#) $Id: pager.c,v 1.25 2006/10/12 21:34:21 rmsimpson Exp $
** @(#) $Id: pager.c,v 1.26 2007/01/10 14:50:46 rmsimpson Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
#include "os.h"
#include "pager.h"
#include <assert.h>
#include <string.h>

/*
** Macros for troubleshooting.  Normally turned off
*/
#if 0
#define sqlite3DebugPrintf printf
#define TRACE1(X)       sqlite3DebugPrintf(X)
#define TRACE2(X,Y)     sqlite3DebugPrintf(X,Y)
#define TRACE3(X,Y,Z)   sqlite3DebugPrintf(X,Y,Z)
#define TRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W)
#define TRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V)
#else
#define TRACE1(X)

#else
# define MEMDB pPager->memDb
#endif

/*
** The default size of a disk sector
*/
#ifndef PAGER_SECTOR_SIZE
#define PAGER_SECTOR_SIZE 512
# define PAGER_SECTOR_SIZE 512
#endif

/*
** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
** reserved for working around a windows/posix incompatibility). It is
** used in the journal to signify that the remainder of the journal file 
** is devoted to storing a master journal name - there are no more pages to
** roll back. See comments for function writeMasterJournal() for details.

*/
#ifdef SQLITE_TEST
  int pager3_refinfo_enable = 0;
  static void pager_refinfo(PgHdr *p){
    static int cnt = 0;
    if( !pager3_refinfo_enable ) return;
    sqlite3DebugPrintf(
       "REFCNT: %4d addr=%p nRef=%d\n",
       p->pgno, PGHDR_TO_DATA(p), p->nRef
       "REFCNT: %4d addr=%p nRef=%-3d total=%d\n",
       p->pgno, PGHDR_TO_DATA(p), p->nRef, p->pPager->nRef
    );
    cnt++;   /* Something to set a breakpoint on */
  }
# define REFINFO(X)  pager_refinfo(X)
#else
# define REFINFO(X)
#endif

  if( pPager->aHash==0 ) return 0;
  p = pPager->aHash[pgno & (pPager->nHash-1)];
  while( p && p->pgno!=pgno ){
    p = p->pNextHash;
  }
  return p;
}

/*
** Unlock the database file.
**
** Once all locks have been removed from the database file, other
** processes or threads might change the file.  So make sure all of
** our internal cache is invalidated.
*/
static void pager_unlock(Pager *pPager){
  if( !MEMDB ){
    sqlite3OsUnlock(pPager->fd, NO_LOCK);
    pPager->dbSize = -1;
  }
  pPager->state = PAGER_UNLOCK;
  assert( pPager->pAll==0 );
}


/*
** Unlock the database and clear the in-memory cache.  This routine
** sets the state of the pager back to what it was when it was first
** opened.  Any outstanding pages are invalidated and subsequent attempts
** to access those pages will likely result in a coredump.
*/

  pPager->nHash = 0;
  sqliteFree(pPager->aHash);
  pPager->nPage = 0;
  pPager->aHash = 0;
  if( pPager->state>=PAGER_RESERVED ){
    sqlite3pager_rollback(pPager);
  }
  sqlite3OsUnlock(pPager->fd, NO_LOCK);
  pager_unlock(pPager);
  pPager->state = PAGER_UNLOCK;
  pPager->dbSize = -1;
  pPager->nRef = 0;
  assert( pPager->journalOpen==0 );
  assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) );
}

/*
** When this routine is called, the pager has the journal file open and
** a RESERVED or EXCLUSIVE lock on the database.  This routine releases
** the database lock and acquires a SHARED lock in its place.  The journal
** file is deleted and closed.

  }
  rc = sqlite3OsUnlock(pPager->fd, SHARED_LOCK);
  pPager->state = PAGER_SHARED;
  pPager->origDbSize = 0;
  pPager->setMaster = 0;
  pPager->needSync = 0;
  pPager->pFirstSynced = pPager->pFirst;
  pPager->dbSize = -1;
  return rc;
}

/*
** Compute and return a checksum for the page of data.
**
** This is not a real checksum.  It is really just the sum of the 

  }
  
  /* Truncate the database back to its original size.
  */
  if( pPager->state>=PAGER_EXCLUSIVE ){
    rc = pager_truncate(pPager, pPager->stmtSize);
  }
  assert( pPager->state>=PAGER_SHARED );
  pPager->dbSize = pPager->stmtSize;

  /* Figure out how many records are in the statement journal.
  */
  assert( pPager->stmtInUse && pPager->journalOpen );
  sqlite3OsSeek(pPager->stfd, 0);
  nRec = pPager->stmtNRec;

**
** No error checking is done. The rational for this is that this function 
** may be called even if the file does not exist or contain a header. In 
** these cases sqlite3OsRead() will return an error, to which the correct 
** response is to zero the memory at pDest and continue.  A real IO error 
** will presumably recur and be picked up later (Todo: Think about this).
*/
void sqlite3pager_read_fileheader(Pager *pPager, int N, unsigned char *pDest){
int sqlite3pager_read_fileheader(Pager *pPager, int N, unsigned char *pDest){
  int rc = SQLITE_OK;
  memset(pDest, 0, N);
  if( MEMDB==0 ){
    disable_simulated_io_errors();
    sqlite3OsSeek(pPager->fd, 0);
    sqlite3OsRead(pPager->fd, pDest, N);
    enable_simulated_io_errors();
    rc = sqlite3OsRead(pPager->fd, pDest, N);
    if( rc==SQLITE_IOERR_SHORT_READ ){
      rc = SQLITE_OK;
  }
    }
  }
  return rc;
}

/*
** Return the total number of pages in the disk file associated with
** pPager. 
**
** If the PENDING_BYTE lies on the page directly after the end of the

** false or until the lock succeeds.
**
** Return SQLITE_OK on success and an error code if we cannot obtain
** the lock.
*/
static int pager_wait_on_lock(Pager *pPager, int locktype){
  int rc;

  /* The OS lock values must be the same as the Pager lock values */
  assert( PAGER_SHARED==SHARED_LOCK );
  assert( PAGER_RESERVED==RESERVED_LOCK );
  assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );

  /* If the file is currently unlocked then the size must be unknown */
  assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB );

  if( pPager->state>=locktype ){
    rc = SQLITE_OK;
  }else{
    do {
      rc = sqlite3OsLock(pPager->fd, locktype);
    }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) );
    if( rc==SQLITE_OK ){
      pPager->state = locktype;
    }
  }
  return rc;
}

/*
** Truncate the file to the number of pages specified.
*/
int sqlite3pager_truncate(Pager *pPager, Pgno nPage){
  int rc;
  assert( pPager->state>=PAGER_SHARED || MEMDB );
  sqlite3pager_pagecount(pPager);
  if( pPager->errCode ){
    rc = pPager->errCode;
    return rc;
  }
  if( nPage>=(unsigned)pPager->dbSize ){
    return SQLITE_OK;

**
** This function always succeeds. If a transaction is active an attempt
** is made to roll it back. If an error occurs during the rollback 
** a hot journal may be left in the filesystem but no error is returned
** to the caller.
*/
int sqlite3pager_close(Pager *pPager){
  PgHdr *pPg, *pNext;
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  /* A malloc() cannot fail in sqlite3ThreadData() as one or more calls to 
  ** malloc() must have already been made by this thread before it gets
  ** to this point. This means the ThreadData must have been allocated already
  ** so that ThreadData.nAlloc can be set.
  */
  ThreadData *pTsd = sqlite3ThreadData();
  assert( pPager );
  assert( pTsd && pTsd->nAlloc );
#endif

  switch( pPager->state ){
    case PAGER_RESERVED:
    case PAGER_SYNCED: 
    case PAGER_EXCLUSIVE: {
      /* We ignore any IO errors that occur during the rollback
      ** operation. So disable IO error simulation so that testing
      ** works more easily.
      */
      disable_simulated_io_errors();
      sqlite3pager_rollback(pPager);
      enable_simulated_io_errors();
  disable_simulated_io_errors();
  pPager->errCode = 0;
  pager_reset(pPager);
  enable_simulated_io_errors();
      if( !MEMDB ){
        sqlite3OsUnlock(pPager->fd, NO_LOCK);
      }
      assert( pPager->errCode || pPager->journalOpen==0 );
      break;
    }
    case PAGER_SHARED: {
      if( !MEMDB ){
        sqlite3OsUnlock(pPager->fd, NO_LOCK);
      }
      break;
    }
    default: {
      /* Do nothing */
      break;
    }
  }
  for(pPg=pPager->pAll; pPg; pPg=pNext){
#ifndef NDEBUG
    if( MEMDB ){
      PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
      assert( !pPg->alwaysRollback );
      assert( !pHist->pOrig );
      assert( !pHist->pStmt );
    }
#endif
    pNext = pPg->pNextAll;
    sqliteFree(pPg);
  }
  TRACE2("CLOSE %d\n", PAGERID(pPager));
  assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) );
  if( pPager->journalOpen ){
    sqlite3OsClose(&pPager->jfd);
  }
  sqliteFree(pPager->aInJournal);
  if( pPager->stmtOpen ){

       ** 
       ** Because the intermediate RESERVED lock is not requested, the
       ** second process will get to this point in the code and fail to
       ** obtain it's own EXCLUSIVE lock on the database file.
       */
       rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
       if( rc!=SQLITE_OK ){
         sqlite3OsUnlock(pPager->fd, NO_LOCK);
         pager_unlock(pPager);
         pPager->state = PAGER_UNLOCK;
         return pager_error(pPager, rc);
       }
       pPager->state = PAGER_EXCLUSIVE;

       /* Open the journal for reading only.  Return SQLITE_BUSY if
       ** we are unable to open the journal file. 
       **
       ** The journal file does not need to be locked itself.  The
       ** journal file is never open unless the main database file holds
       ** a write lock, so there is never any chance of two or more
       ** processes opening the journal at the same time.
       */
       rc = sqlite3OsOpenReadOnly(pPager->zJournal, &pPager->jfd);
       if( rc!=SQLITE_OK ){
         sqlite3OsUnlock(pPager->fd, NO_LOCK);
         pager_unlock(pPager);
         pPager->state = PAGER_UNLOCK;
         return SQLITE_BUSY;
       }
       pPager->journalOpen = 1;
       pPager->journalStarted = 0;
       pPager->journalOff = 0;
       pPager->setMaster = 0;
       pPager->journalHdr = 0;

      rc = sqlite3OsSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize);
      if( rc==SQLITE_OK ){
        rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg),
                              pPager->pageSize);
      }
      TRACE3("FETCH %d page %d\n", PAGERID(pPager), pPg->pgno);
      CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
      if( rc!=SQLITE_OK ){
      if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
        i64 fileSize;
        int rc2 = sqlite3OsFileSize(pPager->fd, &fileSize);
        if( rc2!=SQLITE_OK || fileSize>=pgno*pPager->pageSize ){
	  /* An IO error occured in one of the the sqlite3OsSeek() or
          ** sqlite3OsRead() calls above. */
          pPg->pgno = 0;
          sqlite3pager_unref(PGHDR_TO_DATA(pPg));
          return rc;
        pPg->pgno = 0;
        sqlite3pager_unref(PGHDR_TO_DATA(pPg));
        return rc;
        }else{
          clear_simulated_io_error();
          memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
        }
      }else{
        TEST_INCR(pPager->nRead);
      }
    }

    /* Link the page into the page hash table */
    h = pgno & (pPager->nHash-1);

    /* If this was a malloc() failure, then we will not be closing the pager
    ** file. So delete any journal file we may have just created. Otherwise,
    ** the system will get confused, we have a read-lock on the file and a
    ** mysterious journal has appeared in the filesystem.
    */
    sqlite3OsDelete(pPager->zJournal);
  }else{
    sqlite3OsUnlock(pPager->fd, NO_LOCK);
    pager_reset(pPager);
    pPager->state = PAGER_UNLOCK;
  }
  return rc;
}

/*
** Acquire a write-lock on the database.  The lock is removed when
** the any of the following happen:

      }
      page_add_to_stmt_list(pPg);
    }
  }

  /* Update the database size and return.
  */
  assert( pPager->state>=PAGER_SHARED );
  if( pPager->dbSize<(int)pPg->pgno ){
    pPager->dbSize = pPg->pgno;
    if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){
      pPager->dbSize++;
    }
  }
  return rc;

  if( MEMDB ) return;

  pPg = pager_lookup(pPager, pgno);
  assert( pPg!=0 );  /* We never call _dont_write unless the page is in mem */
  pPg->alwaysRollback = 1;
  if( pPg->dirty && !pPager->stmtInUse ){
    assert( pPager->state>=PAGER_SHARED );
    if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){
      /* If this pages is the last page in the file and the file has grown
      ** during the current transaction, then do NOT mark the page as clean.
      ** When the database file grows, we must make sure that the last page
      ** gets written at least once so that the disk file will be the correct
      ** size. If you do not write this page and the size of the file
      ** on the disk ends up being too small, that can lead to database

** means that the pager does not have to record the given page in the
** rollback journal.
*/
void sqlite3pager_dont_rollback(void *pData){
  PgHdr *pPg = DATA_TO_PGHDR(pData);
  Pager *pPager = pPg->pPager;

  assert( pPager->state>=PAGER_RESERVED );
  if( pPager->state!=PAGER_EXCLUSIVE || pPager->journalOpen==0 ) return;
  if( pPager->journalOpen==0 ) return;
  if( pPg->alwaysRollback || pPager->alwaysRollback || MEMDB ) return;
  if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){
    assert( pPager->aInJournal!=0 );
    pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
    pPg->inJournal = 1;
    if( pPager->stmtInUse ){
      pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);

    return SQLITE_OK;
  }
  if( pPager->dirtyCache==0 ){
    /* Exit early (without doing the time-consuming sqlite3OsSync() calls)
    ** if there have been no changes to the database file. */
    assert( pPager->needSync==0 );
    rc = pager_unwritelock(pPager);
    pPager->dbSize = -1;
    return rc;
  }
  assert( pPager->journalOpen );
  rc = sqlite3pager_sync(pPager, 0, 0);
  if( rc==SQLITE_OK ){
    rc = pager_unwritelock(pPager);
    pPager->dbSize = -1;
  }
  return rc;
}

/*
** Rollback all changes.  The database falls back to PAGER_SHARED mode.
** All in-memory cache pages revert to their original data contents.

    pPager->stmtInUse = 0;
    pPager->state = PAGER_SHARED;
    return SQLITE_OK;
  }

  if( !pPager->dirtyCache || !pPager->journalOpen ){
    rc = pager_unwritelock(pPager);
    pPager->dbSize = -1;
    return rc;
  }

  if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
    if( pPager->state>=PAGER_EXCLUSIVE ){
      pager_playback(pPager);
    }

** open.  A new statement journal is created that can be used to rollback
** changes of a single SQL command within a larger transaction.
*/
int sqlite3pager_stmt_begin(Pager *pPager){
  int rc;
  char zTemp[SQLITE_TEMPNAME_SIZE];
  assert( !pPager->stmtInUse );
  assert( pPager->state>=PAGER_SHARED );
  assert( pPager->dbSize>=0 );
  TRACE2("STMT-BEGIN %d\n", PAGERID(pPager));
  if( MEMDB ){
    pPager->stmtInUse = 1;
    pPager->stmtSize = pPager->dbSize;
    return SQLITE_OK;
  }

**    May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the interface that the sqlite page cache
** subsystem.  The page cache subsystem reads and writes a file a page
** at a time and provides a journal for rollback.
**
** @(#) $Id: pager.h,v 1.24 2006/10/12 21:34:21 rmsimpson Exp $
** @(#) $Id: pager.h,v 1.25 2007/01/10 14:50:46 rmsimpson Exp $
*/

#ifndef _PAGER_H_
#define _PAGER_H_

/*
** The default size of a database page.

*/
int sqlite3pager_open(Pager **ppPager, const char *zFilename,
                     int nExtra, int flags);
void sqlite3pager_set_busyhandler(Pager*, BusyHandler *pBusyHandler);
void sqlite3pager_set_destructor(Pager*, void(*)(void*,int));
void sqlite3pager_set_reiniter(Pager*, void(*)(void*,int));
int sqlite3pager_set_pagesize(Pager*, int);
void sqlite3pager_read_fileheader(Pager*, int, unsigned char*);
int sqlite3pager_read_fileheader(Pager*, int, unsigned char*);
void sqlite3pager_set_cachesize(Pager*, int);
int sqlite3pager_close(Pager *pPager);
int sqlite3pager_get(Pager *pPager, Pgno pgno, void **ppPage);
void *sqlite3pager_lookup(Pager *pPager, Pgno pgno);
int sqlite3pager_ref(void*);
int sqlite3pager_unref(void*);
Pgno sqlite3pager_pagenumber(void*);

**  yy_shift_ofst[]    For each state, the offset into yy_action for
**                     shifting terminals.
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
*/
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   290,   67,  294,   69,  150,  168,  206,  435,   61,   61,
 /*     0 */   290,   67,  300,   69,  150,  168,  205,  420,   61,   61,
 /*    10 */    61,   61,   66,   63,   63,   63,   63,   64,   64,   65,
 /*    20 */    65,   65,   66,  445,  325,  164,  448,  454,   68,   63,
 /*    20 */    65,   65,   66,  430,  322,  164,  433,  439,   68,   63,
 /*    30 */    63,   63,   63,   64,   64,   65,   65,   65,   66,   64,
 /*    40 */    64,   65,   65,   65,   66,   60,   58,  298,  458,  459,
 /*    50 */   455,  455,   62,   62,   61,   61,   61,   61,  517,   63,
 /*    40 */    64,   65,   65,   65,   66,   60,   58,  296,  443,  444,
 /*    50 */   440,  440,   62,   62,   61,   61,   61,   61,  487,   63,
 /*    60 */    63,   63,   63,   64,   64,   65,   65,   65,   66,  290,
 /*    70 */   321,   67,  435,   69,  150,   79,  160,  114,  224,  317,
 /*    80 */   229,  318,  172,  249,  897,  120,  585,  519,  522,    2,
 /*    90 */   250,  571,  426,   35,  223,  448,  454,  532,   20,   57,
 /*    70 */   318,   67,  420,   69,  150,   79,  160,  114,  240,  341,
 /*    80 */   245,  342,  172,  249,  897,  120,  585,  190,  522,    2,
 /*    90 */   250,  571,  411,   35,  223,  433,  439,  532,   20,   57,
 /*   100 */   388,  385,   63,   63,   63,   63,   64,   64,   65,   65,
 /*   110 */    65,   66,  290,  477,   60,   58,  298,  458,  459,  455,
 /*   120 */   455,   62,   62,   61,   61,   61,   61,  393,   63,   63,
 /*   130 */    63,   63,   64,   64,   65,   65,   65,   66,  448,  454,
 /*   140 */    91,  314,  389,  484,  236,  387,  271,  204,    2,   83,
 /*   150 */   586,  388,  385,  474,  196,  443,  209,   60,   58,  298,
 /*   160 */   458,  459,  455,  455,   62,   62,   61,   61,   61,   61,
 /*   110 */    65,   66,  290,  489,   60,   58,  296,  443,  444,  440,
 /*   120 */   440,   62,   62,   61,   61,   61,   61,  393,   63,   63,
 /*   130 */    63,   63,   64,   64,   65,   65,   65,   66,  433,  439,
 /*   140 */    91,  314,  389,  473,  230,  529,  504,  204,  168,   55,
 /*   150 */   420,  197,  528,  407,  196,  428,  208,   60,   58,  296,
 /*   160 */   443,  444,  440,  440,   62,   62,   61,   61,   61,   61,
 /*   170 */   170,   63,   63,   63,   63,   64,   64,   65,   65,   65,
 /*   180 */    66,  290,  490,  443,  209,  274,  109,  272,  427,  447,
 /*   190 */   406,  284,  394,  395,  445,  521,  164,  321,  511,   67,
 /*   200 */   530,   69,  150,  567,  427,  143,  520,  448,  454,  145,
 /*   210 */   146,  583,  888,  376,  888,  515,  171,  156,  518,  426,
 /*   220 */    40,  340,  430,   19,  290,  140,   60,   58,  298,  458,
 /*   230 */   459,  455,  455,   62,   62,   61,   61,   61,   61,  384,
 /*   180 */    66,  290,  479,  428,  208,  412,  109,   81,  412,  432,
 /*   190 */   406,  284,  394,  395,  430,  521,  164,  318,  517,   67,
 /*   200 */   530,   69,  150,  567,  412,  492,  493,  433,  439,  145,
 /*   210 */   146,  583,  888,  376,  888,  420,  171,  156,  488,  411,
 /*   220 */    40,  337,  415,   19,  290,  140,   60,   58,  296,  443,
 /*   230 */   444,  440,  440,   62,   62,   61,   61,   61,   61,  384,
 /*   240 */    63,   63,   63,   63,   64,   64,   65,   65,   65,   66,
 /*   250 */   448,  454,  580,  408,  409,  432,  432,  432,  332,  335,
 /*   260 */   240,  549,   67,  472,   69,  150,  273,  290,  294,   60,
 /*   270 */    58,  298,  458,  459,  455,  455,   62,   62,   61,   61,
 /*   280 */    61,   61,  124,   63,   63,   63,   63,   64,   64,   65,
 /*   290 */    65,   65,   66,  448,  454,  405,  514,  393,  293,  548,
 /*   300 */    65,   65,   65,   66,  511,  393,  546,  409,  447,  297,
 /*   310 */   438,  439,   60,   58,  298,  458,  459,  455,  455,   62,
 /*   320 */    62,   61,   61,   61,   61,  206,   63,   63,   63,   63,
 /*   330 */    64,   64,   65,   65,   65,   66,  523,  518,  369,  290,
 /*   340 */    75,  430,  148,  494,  224,  317,  229,  318,  172,  249,
 /*   350 */   370,  267,  266,    1,  579,  289,  250,  393,  420,  449,
 /*   360 */   450,  206,  394,  395,  177,  448,  454,  343,  346,  347,
 /*   370 */   394,  395,  208,  360,  432,  432,  432,  363,  168,  348,
 /*   380 */   435,  452,  453,   78,   60,   58,  298,  458,  459,  455,
 /*   390 */   455,   62,   62,   61,   61,   61,   61,  480,   63,   63,
 /*   400 */    63,   63,   64,   64,   65,   65,   65,   66,  290,  451,
 /*   410 */   177,  566,  497,  343,  346,  347,   21,  321,  522,  321,
 /*   420 */   435,  321,  394,  395,  321,  348,  479,  404,   20,  568,
 /*   430 */   569,  493,  151,  177,  448,  454,  343,  346,  347,  426,
 /*   440 */    34,  426,   34,  426,   34,  435,  426,   34,  348,  197,
 /*   450 */   237,  147,  531,   60,   58,  298,  458,  459,  455,  455,
 /*   460 */    62,   62,   61,   61,   61,   61,  427,   63,   63,   63,
 /*   470 */    63,   64,   64,   65,   65,   65,   66,  290,  230,  351,
 /*   480 */   412,  516,  301,  427,  337,  435,  321,  155,  321,  299,
 /*   490 */   321,  208,  413,  154,  469,    9,  469,  462,  468,  393,
 /*   500 */    74,  469,   76,  448,  454,  414,  173,  410,  426,   40,
 /*   510 */   426,   48,  426,   48,  324,  438,  439,  411,  327,  479,
 /*   520 */   461,  461,   60,   58,  298,  458,  459,  455,  455,   62,
 /*   530 */    62,   61,   61,   61,   61,  463,   63,   63,   63,   63,
 /*   540 */    64,   64,   65,   65,   65,   66,  290,  321,  503,  238,
 /*   550 */   253,  484,  393,  341,  412,  149,  425,  309,  338,  310,
 /*   560 */   424,  393,  292,  393,  394,  395,  413,  250,  504,  426,
 /*   570 */    27,  241,  448,  454,  435,  426,    3,  208,  543,  414,
 /*   580 */   322,  331,  583,  887,  327,  887,  461,  461,  488,  427,
 /*   590 */   242,   60,   58,  298,  458,  459,  455,  455,   62,   62,
 /*   600 */    61,   61,   61,   61,  255,   63,   63,   63,   63,   64,
 /*   610 */    64,   65,   65,   65,   66,  290,  371,  394,  395,  492,
 /*   620 */    90,  302,  327,  580,  461,  461,  394,  395,  394,  395,
 /*   630 */   321,  529,  498,  321,  396,  397,  398,  522,  528,  435,
 /*   640 */   219,  448,  454,  259,  481,  257,  576,   20,  327,  300,
 /*   650 */   461,  461,  426,   28,  545,  426,   23,  509,  290,  342,
 /*   660 */    60,   58,  298,  458,  459,  455,  455,   62,   62,   61,
 /*   670 */    61,   61,   61,  321,   63,   63,   63,   63,   64,   64,
 /*   680 */    65,   65,   65,   66,  448,  454,  425,  539,  357,  539,
 /*   690 */   424,  261,  303,  509,  822,  426,   32,  436,  509,   22,
 /*   700 */   188,  290,  509,   60,   58,  298,  458,  459,  455,  455,
 /*   710 */    62,   62,   61,   61,   61,   61,  321,   63,   63,   63,
 /*   720 */    63,   64,   64,   65,   65,   65,   66,  448,  454,  174,
 /*   730 */   175,  176,  381,  216,  427,  484,  248,  304,  426,   53,
 /*   740 */   509,  509,  261,  261,  290,  261,   60,   70,  298,  458,
 /*   750 */   459,  455,  455,   62,   62,   61,   61,   61,   61,  368,
 /*   250 */   433,  439,  580,  546,  493,  417,  417,  417,  549,  332,
 /*   260 */   234,   67,  460,   69,  150,  583,  887,  290,  887,   60,
 /*   270 */    58,  296,  443,  444,  440,  440,   62,   62,   61,   61,
 /*   280 */    61,   61,  318,   63,   63,   63,   63,   64,   64,   65,
 /*   290 */    65,   65,   66,  433,  439,  177,  548,  393,  343,  346,
 /*   300 */   347,  515,  490,  271,  411,   40,  580,  473,  432,  224,
 /*   310 */   348,  408,   60,   58,  296,  443,  444,  440,  440,   62,
 /*   320 */    62,   61,   61,   61,   61,  523,   63,   63,   63,   63,
 /*   330 */    64,   64,   65,   65,   65,   66,  303,  488,  300,  290,
 /*   340 */    75,  415,  274,  483,  272,  232,  236,  370,  267,  266,
 /*   350 */   318,   65,   65,   65,   66,  173,  393,  148,  205,  434,
 /*   360 */   435,  231,  394,  395,  177,  433,  439,  343,  346,  347,
 /*   370 */   293,  515,  411,   34,  417,  417,  417,  378,  477,  348,
 /*   380 */   248,  437,  438,   78,   60,   58,  296,  443,  444,  440,
 /*   390 */   440,   62,   62,   61,   61,   61,   61,  205,   63,   63,
 /*   400 */    63,   63,   64,   64,   65,   65,   65,   66,  290,  436,
 /*   410 */   377,  292,  486,  114,  240,  341,  245,  342,  172,  249,
 /*   420 */   318,  394,  395,  273,  318,  177,  250,  456,  343,  346,
 /*   430 */   347,  329,  151,  566,  433,  439,  295,  423,  424,  298,
 /*   440 */   348,  387,  411,   34,    2,  360,  411,   34,  469,  363,
 /*   450 */   247,  568,  569,   60,   58,  296,  443,  444,  440,  440,
 /*   460 */    62,   62,   61,   61,   61,   61,  412,   63,   63,   63,
 /*   470 */    63,   64,   64,   65,   65,   65,   66,  290,  522,  155,
 /*   480 */   515,  503,   21,  452,  318,  299,  420,  404,   20,  297,
 /*   490 */   321,  423,  424,  482,  318,  453,  318,  457,    1,  207,
 /*   500 */   335,  457,  393,  433,  439,    9,  411,   34,  454,  393,
 /*   510 */   494,  147,  531,  207,  543,  216,  411,   48,  411,   48,
 /*   520 */   495,  393,   60,   58,  296,  443,  444,  440,  440,   62,
 /*   530 */    62,   61,   61,   61,   61,  351,   63,   63,   63,   63,
 /*   540 */    64,   64,   65,   65,   65,   66,  290,  318,  447,  334,
 /*   550 */   253,  420,  371,  207,  452,  149,  448,  579,  289,  248,
 /*   560 */   393,  457,  173,  309,  235,  310,  453,  394,  395,  411,
 /*   570 */    27,  420,  433,  439,  394,  395,  405,  520,  367,  454,
 /*   580 */   324,  328,  446,  446,  509,  517,  394,  395,  473,  412,
 /*   590 */   545,   60,   58,  296,  443,  444,  440,  440,   62,   62,
 /*   600 */    61,   61,   61,   61,  510,   63,   63,   63,   63,   64,
 /*   610 */    64,   65,   65,   65,   66,  290,  192,  338,  292,  324,
 /*   620 */    90,  446,  446,  250,  522,  394,  395,  238,  319,  393,
 /*   630 */   822,  477,  318,  576,   20,  324,  420,  446,  446,  411,
 /*   640 */     3,  433,  439,  324,  217,  446,  446,  586,  388,  385,
 /*   650 */   412,  515,  470,  515,  411,   28,  515,  302,  290,  581,
 /*   660 */    60,   58,  296,  443,  444,  440,  440,   62,   62,   61,
 /*   670 */    61,   61,   61,  219,   63,   63,   63,   63,   64,   64,
 /*   680 */    65,   65,   65,   66,  433,  439,  304,  481,  305,  167,
 /*   690 */   156,  307,  358,  392,  394,  395,  396,  397,  398,  582,
 /*   700 */   188,  290,  339,   60,   58,  296,  443,  444,  440,  440,
 /*   710 */    62,   62,   61,   61,   61,   61,  318,   63,   63,   63,
 /*   720 */    63,   64,   64,   65,   65,   65,   66,  433,  439,  410,
 /*   730 */   248,  261,  248,  409,  412,  248,  367,  255,  411,   23,
 /*   740 */   539,  357,  539,  261,  290,  261,   60,   70,  296,  443,
 /*   750 */   444,  440,  440,   62,   62,   61,   61,   61,   61,  368,
 /*   760 */    63,   63,   63,   63,   64,   64,   65,   65,   65,   66,
 /*   770 */   448,  454,  247,  392,  244,  305,  307,  248,  167,  156,
 /*   780 */   364,  248,  383,  262,  556,  261,  558,  290,  261,  115,
 /*   790 */    58,  298,  458,  459,  455,  455,   62,   62,   61,   61,
 /*   800 */    61,   61,  321,   63,   63,   63,   63,   64,   64,   65,
 /*   810 */    65,   65,   66,  448,  454,  488,  467,  488,   12,  248,
 /*   820 */   248,  207,    5,  367,  426,   24,  559,  367,   54,  560,
 /*   830 */   312,  119,  441,  441,  298,  458,  459,  455,  455,   62,
 /*   840 */    62,   61,   61,   61,   61,  321,   63,   63,   63,   63,
 /*   850 */    64,   64,   65,   65,   65,   66,   71,  328,  321,    4,
 /*   860 */   321,  541,  321,  296,  261,  540,  261,  426,   51,  321,
 /*   870 */   161,  323,   71,  328,  321,    4,  358,  359,  308,  296,
 /*   880 */   426,   96,  426,   93,  426,   98,  225,  323,  330,  217,
 /*   890 */   431,  426,   99,  218,  444,  321,  426,  110,  226,  447,
 /*   900 */   321,  261,  321,  421,  330,  275,  190,  375,  321,  333,
 /*   910 */   422,  321,  417,  418,  470,  447,  321,  426,  111,   73,
 /*   920 */    72,  192,  426,   16,  426,   97,  152,   71,  319,  320,
 /*   930 */   426,   33,  430,  426,   94,   73,   72,  491,  426,   52,
 /*   940 */   321,  478,  277,   71,  319,  320,   71,  328,  430,    4,
 /*   950 */   321,  206,  321,  296,  321,  427,  486,  321,  169,  179,
 /*   960 */   427,  323,  426,  112,  620,  432,  432,  432,  433,  434,
 /*   970 */    11,  378,  426,  113,  426,   25,  426,   36,  330,  426,
 /*   980 */    37,  432,  432,  432,  433,  434,   11,  483,  326,  447,
 /*   990 */   158,  206,  321,  427,  173,  220,  221,  222,  101,  182,
 /*  1000 */   495,  321,   12,  321,  377,  321,   81,  321,  487,   73,
 /*  1010 */    72,  202,  581,  279,  426,   26,  246,   71,  319,  320,
 /*  1020 */   280,  321,  430,  426,   38,  426,   39,  426,   41,  426,
 /*  1030 */    42,  321,  199,  427,  548,  502,  501,  537,  538,  198,
 /*  1040 */   321,  499,  201,  426,   43,  321,  500,  507,  321,  124,
 /*  1050 */   292,  321,  582,  426,   29,  432,  432,  432,  433,  434,
 /*  1060 */    11,  505,  426,   30,  456,  506,  321,  426,   44,  200,
 /*  1070 */   426,   45,  321,  426,   46,  252,  321,  124,  350,  321,
 /*  1080 */   124,  321,  524,  254,  185,  374,  276,  266,  426,   47,
 /*  1090 */   578,  291,  288,  256,  426,   31,  206,  258,  426,   10,
 /*  1100 */   260,  426,   49,  426,   50,  355,  544,  552,  124,  169,
 /*  1110 */   553,  265,   88,  362,  365,  563,  366,   88,  268,   18,
 /*  1120 */   380,  269,  270,  555,  565,  278,  379,  281,  227,  282,
 /*  1130 */   575,  142,  231,  402,  329,  440,  442,  473,  498,  159,
 /*  1140 */   476,  551,  508,  562,  510,  391,  399,  400,  401,    8,
 /*  1150 */   315,  316,  295,   81,  420,  336,  232,   80,  345,  407,
 /*  1160 */   415,  334,  228,   56,   77,  419,  423,  166,  471,  416,
 /*  1170 */   210,  239,  474,  475,  211,  121,   82,  339,  102,  512,
 /*  1180 */   352,  180,  285,  428,  356,  533,  525,  181,  526,  527,
 /*  1190 */   263,  354,  233,  513,  234,  286,  184,  183,   85,  535,
 /*  1200 */   235,  186,  429,  117,  361,  128,  547,  373,  189,  572,
 /*  1210 */   243,  577,  485,  245,  129,  489,  212,  372,  130,  311,
 /*  1220 */   554,  573,  214,  215,  574,   95,  134,  131,  132,  561,
 /*  1230 */   390,  403,  116,  213,  205,  100,   55,  621,  622,  162,
 /*  1240 */   138,  163,   59,  457,  137,  437,  446,  460,  464,  139,
 /*  1250 */   153,  482,  465,    6,  536,  165,  466,   13,    7,  122,
 /*  1260 */    12,  123,  496,  157,  344,  103,  349,  251,  104,   84,
 /*  1270 */   105,  178,  226,  353,  141,  534,  125,  169,  264,  306,
 /*  1280 */   187,  106,  287,  550,   89,   92,  127,   86,   87,  126,
 /*  1290 */   542,   17,  191,  108,   14,  194,  193,  557,  135,  133,
 /*  1300 */   195,  136,   15,  564,  570,  118,  107,  203,  144,  313,
 /*  1310 */   382,  283,  386,  559,  584,
 /*   770 */   433,  439,  381,  541,  115,  261,  259,  540,  257,  261,
 /*   780 */   364,  174,  175,  176,  262,  261,  556,  290,    5,  359,
 /*   790 */    58,  296,  443,  444,  440,  440,   62,   62,   61,   61,
 /*   800 */    61,   61,  218,   63,   63,   63,   63,   64,   64,   65,
 /*   810 */    65,   65,   66,  433,  439,  477,  558,  205,  466,  468,
 /*   820 */   559,  206,  383,  261,  261,  261,  560,  152,   54,  467,
 /*   830 */   369,  312,  119,  124,  296,  443,  444,  440,  440,   62,
 /*   840 */    62,   61,   61,   61,   61,  416,   63,   63,   63,   63,
 /*   850 */    64,   64,   65,   65,   65,   66,   71,  325,  318,    4,
 /*   860 */   318,  412,  318,  294,  275,  375,  277,  318,   74,  318,
 /*   870 */    76,  320,   71,  325,  318,    4,  308,  498,  499,  294,
 /*   880 */   411,   32,  411,   53,  411,   24,  154,  320,  327,  411,
 /*   890 */    51,  411,   96,  161,  410,  318,  411,   93,  409,  432,
 /*   900 */   318,  421,  318,   22,  327,  426,  426,  179,  318,  501,
 /*   910 */   143,  318,  468,  508,  507,  432,  318,  411,   98,   73,
 /*   920 */    72,  182,  411,   99,  411,  110,  323,   71,  316,  317,
 /*   930 */   411,  111,  415,  411,   16,   73,   72,  480,  411,   97,
 /*   940 */   318,  412,  330,   71,  316,  317,   71,  325,  415,    4,
 /*   950 */   318,  205,  318,  294,  318,  412,  455,  318,   12,  537,
 /*   960 */   538,  320,  411,   33,  462,  417,  417,  417,  418,  419,
 /*   970 */    11,  463,  411,   94,  411,   52,  411,  112,  327,  411,
 /*   980 */   113,  417,  417,  417,  418,  419,   11,  620,  241,  432,
 /*   990 */   158,  475,  318,  169,  429,  220,  221,  222,  101,  458,
 /*  1000 */   242,  318,  441,  318,  484,  318,   12,  318,  472,   73,
 /*  1010 */    72,  202,  476,  279,  411,   25,  246,   71,  316,  317,
 /*  1020 */   280,  318,  415,  411,   36,  411,   37,  411,   26,  411,
 /*  1030 */    38,  318,  199,  505,  548,  513,  252,  124,  124,  198,
 /*  1040 */   318,  506,  201,  411,   39,  318,  511,  350,  318,  124,
 /*  1050 */   544,  318,  124,  411,   41,  417,  417,  417,  418,  419,
 /*  1060 */    11,  512,  411,   42,  524,  254,  318,  411,   43,  200,
 /*  1070 */   411,   29,  318,  411,   30,  552,  318,  169,  553,  318,
 /*  1080 */    88,  318,  256,  318,  185,  374,  276,  266,  411,   44,
 /*  1090 */   258,  291,  318,  260,  411,   45,  205,  265,  411,   46,
 /*  1100 */   318,  411,   47,  411,   31,  411,   10,  563,  578,   88,
 /*  1110 */   288,  355,  362,  365,  411,   49,  366,  268,  269,   18,
 /*  1120 */   380,  270,  411,   50,  555,  565,  278,  379,  281,  282,
 /*  1130 */   575,  142,  225,  402,  425,  427,  326,  504,  551,  461,
 /*  1140 */   465,  562,  159,  391,  399,  243,  400,  514,  516,  401,
 /*  1150 */     8,  413,  226,  315,   81,  333,  227,   80,  331,  228,
 /*  1160 */   345,  229,   77,   56,  209,  166,  459,  233,  210,  407,
 /*  1170 */   464,  121,   82,  336,  340,  491,  496,  301,  244,  501,
 /*  1180 */   497,  500,  502,  102,  518,  519,  414,  285,  352,  525,
 /*  1190 */   180,  526,  527,  533,  237,  181,  474,  239,  354,  478,
 /*  1200 */   211,  286,  184,  214,  535,  183,  215,  356,   85,  361,
 /*  1210 */   117,  186,  128,  547,  189,  372,  554,  373,  311,  561,
 /*  1220 */   572,  129,  130,  131,  138,  573,   95,  132,  577,  263,
 /*  1230 */   137,  134,  574,  390,  403,  621,  536,  213,  622,  100,
 /*  1240 */   162,   59,  163,  422,  431,  442,  445,  139,   89,  449,
 /*  1250 */   153,  165,    6,  450,  451,  122,  471,   13,    7,   92,
 /*  1260 */   123,   12,  485,  157,  212,  108,   83,  103,  104,  116,
 /*  1270 */   344,  251,   84,  105,  349,   17,  178,  353,  242,  534,
 /*  1280 */   141,  125,  306,  187,  106,  169,  126,  287,  542,  264,
 /*  1290 */   118,  550,  127,  191,  313,   14,   86,  193,  194,  135,
 /*  1300 */   557,  195,  133,  564,  136,   15,  107,  570,  382,  283,
 /*  1310 */   144,  203,  386,   87,  584,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */    16,  218,   16,  220,  221,   21,  111,   23,   70,   71,
 /*    10 */    72,   73,   84,   75,   76,   77,   78,   79,   80,   81,
 /*    20 */    82,   83,   84,  162,  163,  164,   42,   43,   74,   75,
 /*    30 */    76,   77,   78,   79,   80,   81,   82,   83,   84,   79,
 /*    40 */    80,   81,   82,   83,   84,   61,   62,   63,   64,   65,
 /*    50 */    66,   67,   68,   69,   70,   71,   72,   73,  170,   75,
 /*    60 */    76,   77,   78,   79,   80,   81,   82,   83,   84,   16,
 /*    70 */   148,  218,   88,  220,  221,   22,   90,   91,   92,   93,
 /*    80 */    94,   95,   96,   97,  140,  141,  142,  170,  148,  145,
 /*    80 */    94,   95,   96,   97,  140,  141,  142,   22,  148,  145,
 /*    90 */   104,  238,  170,  171,  154,   42,   43,  157,  158,   46,
 /*   100 */     1,    2,   75,   76,   77,   78,   79,   80,   81,   82,
 /*   110 */    83,   84,   16,   22,   61,   62,   63,   64,   65,   66,
 /*   110 */    83,   84,   16,  170,   61,   62,   63,   64,   65,   66,
 /*   120 */    67,   68,   69,   70,   71,   72,   73,   23,   75,   76,
 /*   130 */    77,   78,   79,   80,   81,   82,   83,   84,   42,   43,
 /*   140 */    44,  143,  144,  162,  222,  142,   14,  149,  145,   19,
 /*   150 */     0,    1,    2,   23,  156,   79,   80,   61,   62,   63,
 /*   140 */    44,  143,  144,  162,  222,  177,  178,  149,   21,   19,
 /*   150 */    23,  156,  184,   23,  156,   79,   80,   61,   62,   63,
 /*   160 */    64,   65,   66,   67,   68,   69,   70,   71,   72,   73,
 /*   170 */   156,   75,   76,   77,   78,   79,   80,   81,   82,   83,
 /*   180 */    84,   16,  201,   79,   80,   53,   21,   55,  190,   59,
 /*   180 */    84,   16,  201,   79,   80,  190,   21,  122,  190,   59,
 /*   190 */   169,  159,   88,   89,  162,  163,  164,  148,  177,  218,
 /*   200 */   182,  220,  221,   99,  190,  114,  161,   42,   43,   79,
 /*   210 */    80,   19,   20,  215,   22,  170,  202,  203,   88,  170,
 /*   200 */   182,  220,  221,   99,  190,  186,  187,   42,   43,   79,
 /*   210 */    80,   19,   20,  215,   22,   88,  202,  203,   88,  170,
 /*   220 */   171,  207,   92,   19,   16,   21,   61,   62,   63,   64,
 /*   230 */    65,   66,   67,   68,   69,   70,   71,   72,   73,  241,
 /*   240 */    75,   76,   77,   78,   79,   80,   81,   82,   83,   84,
 /*   250 */    42,   43,   60,  186,  187,  125,  126,  127,  187,  210,
 /*   260 */   211,   11,  218,  219,  220,  221,  134,   16,   16,   61,
 /*   250 */    42,   43,   60,  186,  187,  125,  126,  127,   11,  210,
 /*   260 */   211,  218,  219,  220,  221,   19,   20,   16,   22,   61,
 /*   270 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   280 */    72,   73,   22,   75,   76,   77,   78,   79,   80,   81,
 /*   290 */    82,   83,   84,   42,   43,  168,  169,   23,  151,   49,
 /*   300 */    81,   82,   83,   84,  177,   23,  186,  187,   59,  165,
 /*   310 */   166,  167,   61,   62,   63,   64,   65,   66,   67,   68,
 /*   320 */    69,   70,   71,   72,   73,  111,   75,   76,   77,   78,
 /*   330 */    79,   80,   81,   82,   83,   84,  182,   88,  124,   16,
 /*   340 */   132,   92,   22,   20,   92,   93,   94,   95,   96,   97,
 /*   350 */   100,  101,  102,   19,  244,  245,  104,   23,   98,   42,
 /*   360 */    43,  111,   88,   89,   90,   42,   43,   93,   94,   95,
 /*   370 */    88,   89,  228,  226,  125,  126,  127,  230,   21,  105,
 /*   380 */    23,   64,   65,  132,   61,   62,   63,   64,   65,   66,
 /*   390 */    67,   68,   69,   70,   71,   72,   73,  115,   75,   76,
 /*   280 */    72,   73,  148,   75,   76,   77,   78,   79,   80,   81,
 /*   290 */    82,   83,   84,   42,   43,   90,   49,   23,   93,   94,
 /*   300 */    95,  148,  161,   14,  170,  171,   60,  162,   59,  191,
 /*   310 */   105,  170,   61,   62,   63,   64,   65,   66,   67,   68,
 /*   320 */    69,   70,   71,   72,   73,  182,   75,   76,   77,   78,
 /*   330 */    79,   80,   81,   82,   83,   84,  183,   88,   16,   16,
 /*   340 */   132,   92,   53,   20,   55,  211,  201,  100,  101,  102,
 /*   350 */   148,   81,   82,   83,   84,   43,   23,   22,  111,   42,
 /*   360 */    43,  148,   88,   89,   90,   42,   43,   93,   94,   95,
 /*   370 */   151,  148,  170,  171,  125,  126,  127,   91,  148,  105,
 /*   380 */   227,   64,   65,  132,   61,   62,   63,   64,   65,   66,
 /*   390 */    67,   68,   69,   70,   71,   72,   73,  111,   75,   76,
 /*   400 */    77,   78,   79,   80,   81,   82,   83,   84,   16,   92,
 /*   410 */    90,  148,   20,   93,   94,   95,   19,  148,  148,  148,
 /*   420 */    23,  148,   88,   89,  148,  105,   22,  157,  158,  166,
 /*   430 */   167,   20,  156,   90,   42,   43,   93,   94,   95,  170,
 /*   440 */   171,  170,  171,  170,  171,   88,  170,  171,  105,  156,
 /*   450 */   148,  181,  182,   61,   62,   63,   64,   65,   66,   67,
 /*   410 */   124,   99,   20,   91,   92,   93,   94,   95,   96,   97,
 /*   420 */   148,   88,   89,  134,  148,   90,  104,  225,   93,   94,
 /*   430 */    95,  187,  156,  148,   42,   43,  165,  166,  167,  209,
 /*   440 */   105,  142,  170,  171,  145,  226,  170,  171,  115,  230,
 /*   450 */   227,  166,  167,   61,   62,   63,   64,   65,   66,   67,
 /*   460 */    68,   69,   70,   71,   72,   73,  190,   75,   76,   77,
 /*   470 */    78,   79,   80,   81,   82,   83,   84,   16,  191,   16,
 /*   480 */    12,   20,  213,  190,  213,   88,  148,  148,  148,  213,
 /*   490 */   148,  228,   24,   89,  225,   19,  225,   20,  225,   23,
 /*   500 */   131,  225,  133,   42,   43,   37,   43,   39,  170,  171,
 /*   510 */   170,  171,  170,  171,  165,  166,  167,   49,  107,  115,
 /*   520 */   109,  110,   61,   62,   63,   64,   65,   66,   67,   68,
 /*   530 */    69,   70,   71,   72,   73,   20,   75,   76,   77,   78,
 /*   540 */    79,   80,   81,   82,   83,   84,   16,  148,   30,  211,
 /*   550 */    20,  162,   23,  148,   12,  156,  108,  217,  148,  217,
 /*   560 */   112,   23,   99,   23,   88,   89,   24,  104,   50,  170,
 /*   570 */   171,  148,   42,   43,   23,  170,  171,  228,   18,   37,
 /*   580 */   148,   39,   19,   20,  107,   22,  109,  110,  148,  190,
 /*   590 */   201,   61,   62,   63,   64,   65,   66,   67,   68,   69,
 /*   600 */    70,   71,   72,   73,   14,   75,   76,   77,   78,   79,
 /*   610 */    80,   81,   82,   83,   84,   16,   56,   88,   89,   81,
 /*   620 */    21,  103,  107,   60,  109,  110,   88,   89,   88,   89,
 /*   630 */   148,  177,  178,  148,    7,    8,    9,  148,  184,   88,
 /*   640 */   146,   42,   43,   53,  115,   55,  157,  158,  107,  209,
 /*   650 */   109,  110,  170,  171,   94,  170,  171,  148,   16,   81,
 /*   470 */    78,   79,   80,   81,   82,   83,   84,   16,  148,  148,
 /*   480 */   148,   20,   19,   12,  148,  213,   23,  157,  158,  213,
 /*   490 */   165,  166,  167,   20,  148,   24,  148,  225,   19,  228,
 /*   500 */   148,  225,   23,   42,   43,   19,  170,  171,   37,   23,
 /*   510 */    39,  181,  182,  228,   18,  183,  170,  171,  170,  171,
 /*   520 */    49,   23,   61,   62,   63,   64,   65,   66,   67,   68,
 /*   530 */    69,   70,   71,   72,   73,   16,   75,   76,   77,   78,
 /*   540 */    79,   80,   81,   82,   83,   84,   16,  148,   20,  213,
 /*   550 */    20,   88,   56,  228,   12,  156,   20,  244,  245,  227,
 /*   560 */    23,  225,   43,  217,  148,  217,   24,   88,   89,  170,
 /*   570 */   171,   23,   42,   43,   88,   89,  168,  169,  148,   37,
 /*   580 */   107,   39,  109,  110,   30,  177,   88,   89,  162,  190,
 /*   590 */    94,   61,   62,   63,   64,   65,   66,   67,   68,   69,
 /*   600 */    70,   71,   72,   73,   50,   75,   76,   77,   78,   79,
 /*   610 */    80,   81,   82,   83,   84,   16,  156,  148,   99,  107,
 /*   620 */    21,  109,  110,  104,  148,   88,   89,  201,  148,   23,
 /*   630 */   134,  148,  148,  157,  158,  107,   88,  109,  110,  170,
 /*   640 */   171,   42,   43,  107,  214,  109,  110,    0,    1,    2,
 /*   650 */   190,  148,  115,  148,  170,  171,  148,  103,   16,   20,
 /*   660 */    61,   62,   63,   64,   65,   66,   67,   68,   69,   70,
 /*   670 */    71,   72,   73,  148,   75,   76,   77,   78,   79,   80,
 /*   680 */    81,   82,   83,   84,   42,   43,  108,  100,  101,  102,
 /*   690 */   112,  148,  183,  148,  134,  170,  171,   20,  148,   22,
 /*   700 */   156,   16,  148,   61,   62,   63,   64,   65,   66,   67,
 /*   670 */    71,   72,   73,  146,   75,   76,   77,   78,   79,   80,
 /*   680 */    81,   82,   83,   84,   42,   43,  183,   81,  183,  202,
 /*   690 */   203,  183,  209,  148,   88,   89,    7,    8,    9,   60,
 /*   700 */   156,   16,   81,   61,   62,   63,   64,   65,   66,   67,
 /*   710 */    68,   69,   70,   71,   72,   73,  148,   75,   76,   77,
 /*   720 */    78,   79,   80,   81,   82,   83,   84,   42,   43,  100,
 /*   730 */   101,  102,  189,  183,  190,  162,  227,  183,  170,  171,
 /*   740 */   148,  148,  148,  148,   16,  148,   61,   62,   63,   64,
 /*   720 */    78,   79,   80,   81,   82,   83,   84,   42,   43,  108,
 /*   730 */   227,  148,  227,  112,  190,  227,  148,   14,  170,  171,
 /*   740 */   100,  101,  102,  148,   16,  148,   61,   62,   63,   64,
 /*   750 */    65,   66,   67,   68,   69,   70,   71,   72,   73,  215,
 /*   760 */    75,   76,   77,   78,   79,   80,   81,   82,   83,   84,
 /*   770 */    42,   43,  227,  148,  201,  183,  183,  227,  202,  203,
 /*   780 */   236,  227,  239,  189,  189,  148,  189,   16,  148,  148,
 /*   770 */    42,   43,  189,   25,  148,  148,   53,   29,   55,  148,
 /*   780 */   236,  100,  101,  102,  189,  148,  189,   16,  192,   41,
 /*   790 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   800 */    72,   73,  148,   75,   76,   77,   78,   79,   80,   81,
 /*   810 */    82,   83,   84,   42,   43,  148,   20,  148,   22,  227,
 /*   820 */   227,  193,  192,  148,  170,  171,  189,  148,  200,  189,
 /*   830 */   242,  243,  125,  126,   63,   64,   65,   66,   67,   68,
 /*   800 */    72,   73,  214,   75,   76,   77,   78,   79,   80,   81,
 /*   810 */    82,   83,   84,   42,   43,  148,  189,  111,   22,   22,
 /*   820 */   189,  193,  239,  148,  148,  148,  189,  156,  200,  204,
 /*   830 */   124,  242,  243,   22,   63,   64,   65,   66,   67,   68,
 /*   840 */    69,   70,   71,   72,   73,  148,   75,   76,   77,   78,
 /*   850 */    79,   80,   81,   82,   83,   84,   16,   17,  148,   19,
 /*   860 */   148,   25,  148,   23,  148,   29,  148,  170,  171,  148,
 /*   870 */    19,   31,   16,   17,  148,   19,  209,   41,  209,   23,
 /*   880 */   170,  171,  170,  171,  170,  171,   92,   31,   48,  214,
 /*   890 */   148,  170,  171,  214,  162,  148,  170,  171,  104,   59,
 /*   900 */   148,  148,  148,   27,   48,  189,   22,  189,  148,  148,
 /*   910 */    34,  148,    7,    8,  148,   59,  148,  170,  171,   79,
 /*   920 */    80,  156,  170,  171,  170,  171,  156,   87,   88,   89,
 /*   860 */   148,  190,  148,   23,  189,  189,  189,  148,  131,  148,
 /*   870 */   133,   31,   16,   17,  148,   19,  209,    7,    8,   23,
 /*   880 */   170,  171,  170,  171,  170,  171,   89,   31,   48,  170,
 /*   890 */   171,  170,  171,   19,  108,  148,  170,  171,  112,   59,
 /*   900 */   148,   20,  148,   22,   48,  125,  126,  156,  148,   98,
 /*   910 */   114,  148,  115,   91,   92,   59,  148,  170,  171,   79,
 /*   920 */    80,  156,  170,  171,  170,  171,   16,   87,   88,   89,
 /*   930 */   170,  171,   92,  170,  171,   79,   80,   81,  170,  171,
 /*   940 */   148,  204,  189,   87,   88,   89,   16,   17,   92,   19,
 /*   950 */   148,  111,  148,   23,  148,  190,   20,  148,   22,  156,
 /*   960 */   190,   31,  170,  171,  113,  125,  126,  127,  128,  129,
 /*   970 */   130,   91,  170,  171,  170,  171,  170,  171,   48,  170,
 /*   980 */   171,  125,  126,  127,  128,  129,  130,  148,   16,   59,
 /*   990 */     5,  111,  148,  190,   43,   10,   11,   12,   13,  156,
 /*  1000 */    20,  148,   22,  148,  124,  148,  122,  148,  148,   79,
 /*  1010 */    80,   26,   20,   28,  170,  171,  148,   87,   88,   89,
 /*   940 */   148,  190,  148,   87,   88,   89,   16,   17,   92,   19,
 /*   950 */   148,  111,  148,   23,  148,  190,   20,  148,   22,   51,
 /*   960 */    52,   31,  170,  171,   27,  125,  126,  127,  128,  129,
 /*   970 */   130,   34,  170,  171,  170,  171,  170,  171,   48,  170,
 /*   980 */   171,  125,  126,  127,  128,  129,  130,  113,   92,   59,
 /*   990 */     5,   20,  148,   22,  162,   10,   11,   12,   13,  148,
 /*  1000 */   104,  148,   92,  148,   20,  148,   22,  148,  148,   79,
 /*  1010 */    80,   26,  148,   28,  170,  171,  148,   87,   88,   89,
 /*  1020 */    35,  148,   92,  170,  171,  170,  171,  170,  171,  170,
 /*  1030 */   171,  148,   47,  190,   49,   91,   92,   51,   52,   54,
 /*  1040 */   148,  148,   57,  170,  171,  148,  179,   20,  148,   22,
 /*  1050 */    99,  148,   60,  170,  171,  125,  126,  127,  128,  129,
 /*  1060 */   130,  179,  170,  171,   92,  179,  148,  170,  171,   19,
 /*  1030 */   171,  148,   47,  148,   49,   20,   20,   22,   22,   54,
 /*  1040 */   148,  179,   57,  170,  171,  148,  179,   20,  148,   22,
 /*  1050 */    20,  148,   22,  170,  171,  125,  126,  127,  128,  129,
 /*  1060 */   130,  179,  170,  171,  148,  148,  148,  170,  171,   19,
 /*  1070 */   170,  171,  148,  170,  171,   20,  148,   22,   20,  148,
 /*  1080 */    22,  148,  148,  148,  232,  100,  101,  102,  170,  171,
 /*  1090 */    20,  106,   22,  148,  170,  171,  111,  148,  170,  171,
 /*  1100 */   148,  170,  171,  170,  171,  233,   20,   20,   22,   22,
 /*  1110 */    20,  148,   22,  148,  148,   20,  148,   22,  148,   69,
 /*  1120 */   135,  148,  148,  148,  148,  148,  148,  148,  173,  148,
 /*  1130 */   148,  192,  194,  150,  224,  229,  229,  173,  178,    6,
 /*  1140 */   173,  195,  173,  195,  173,  147,  147,  147,  147,   22,
 /*  1150 */   155,   99,   40,  122,   98,  119,  195,  120,  174,  172,
 /*  1160 */   172,  117,  172,  121,  131,  174,  172,  113,  153,  180,
 /*  1170 */   223,   97,   23,  161,  212,  153,   99,  116,   19,  161,
 /*  1180 */    15,  152,  175,  190,   38,  153,  172,  152,  172,  172,
 /*  1190 */   234,  153,  196,  180,  197,  175,  153,  152,  131,  153,
 /*  1200 */   198,  152,  199,   61,  153,   19,  185,   15,  185,   33,
 /*  1210 */   205,  138,  206,  205,  188,  206,  212,  153,  188,  153,
 /*  1220 */   195,  153,  212,  212,  153,  160,  185,  188,  188,  195,
 /*  1230 */     1,   20,   32,  176,   44,  176,   19,  113,  113,  113,
 /*  1240 */   216,  113,   19,   92,  216,   20,   20,  108,   11,   19,
 /*  1250 */    19,  115,   20,  118,  235,   22,   20,   22,  118,   19,
 /*  1260 */    22,   20,   20,  113,   44,   19,   44,   20,   19,   19,
 /*  1270 */    19,   96,  104,   16,   21,   17,   99,   22,  134,   36,
 /*  1280 */    99,   19,    5,    1,  237,  237,  103,   69,   69,   45,
 /*  1290 */    45,  231,  123,  240,   19,   14,  114,   17,  103,  114,
 /*  1300 */   116,  123,   19,  124,   20,  243,   14,  136,   19,  246,
 /*  1310 */    58,  137,    3,  247,    4,
 /*  1090 */   148,  106,  148,  148,  170,  171,  111,  148,  170,  171,
 /*  1100 */   148,  170,  171,  170,  171,  170,  171,   20,   20,   22,
 /*  1110 */    22,  233,  148,  148,  170,  171,  148,  148,  148,   69,
 /*  1120 */   135,  148,  170,  171,  148,  148,  148,  148,  148,  148,
 /*  1130 */   148,  192,  194,  150,  229,  229,  224,  178,  195,  173,
 /*  1140 */   173,  195,    6,  147,  147,  173,  147,  173,  173,  147,
 /*  1150 */    22,  190,  195,  155,  122,  119,  196,  120,  117,  197,
 /*  1160 */   174,  198,  131,  121,  223,  113,  153,   97,  212,   23,
 /*  1170 */   161,  153,   99,  116,   99,  172,  172,   40,  172,   98,
 /*  1180 */   180,  174,  172,   19,  161,  180,  199,  175,   15,  172,
 /*  1190 */   152,  172,  172,  153,  205,  152,  206,  205,  153,  206,
 /*  1200 */   212,  175,  153,  212,  153,  152,  212,   38,  131,  153,
 /*  1210 */    61,  152,   19,  185,  185,  153,  195,   15,  153,  195,
 /*  1220 */    33,  188,  188,  188,  216,  153,  160,  188,  138,  234,
 /*  1230 */   216,  185,  153,    1,   20,  113,  235,  176,  113,  176,
 /*  1240 */   113,   19,  113,   20,   20,   92,  108,   19,  237,   11,
 /*  1250 */    19,   22,  118,   20,   20,   19,  115,   22,  118,  237,
 /*  1260 */    20,   22,   20,  113,   44,  240,   19,   19,   19,   32,
 /*  1270 */    44,   20,   19,   19,   44,  231,   96,   16,  104,   17,
 /*  1280 */    21,   99,   36,   99,   19,   22,   45,    5,   45,  134,
 /*  1290 */   243,    1,  103,  123,  246,   19,   69,  114,   14,  103,
 /*  1300 */    17,  116,  114,  124,  123,   19,   14,   20,   58,  137,
 /*  1310 */    19,  136,    3,   69,    4,
};
#define YY_SHIFT_USE_DFLT (-106)
#define YY_SHIFT_MAX 386
static const short yy_shift_ofst[] = {
 /*     0 */    99,  840,  985,  -16,  840,  930,  930,  930,  274, -105,
 /*    10 */    96,  930,  930,  930,  930,  930,  -46,  250,  104,  540,
 /*    20 */   551,   76,   76,   53,  165,  208,  251,  323,  392,  461,
 /*    10 */    96,  930,  930,  930,  930,  930,  -46,  247,  104,  498,
 /*    20 */   548,   76,   76,   53,  165,  208,  251,  323,  392,  461,
 /*    30 */   530,  599,  642,  685,  642,  642,  642,  642,  642,  642,
 /*    40 */   642,  642,  642,  642,  642,  642,  642,  642,  642,  642,
 /*    50 */   642,  728,  771,  771,  856,  930,  930,  930,  930,  930,
 /*    60 */   930,  930,  930,  930,  930,  930,  930,  930,  930,  930,
 /*    70 */   930,  930,  930,  930,  930,  930,  930,  930,  930,  930,
 /*    80 */   930,  930,  930,  930,  930,  930,  930,  930,  930,  930,
 /*    90 */   930,  930,  930,  -62,  -62,  -14,   27,   27,  -40,  219,
 /*   100 */   463,  560,  540,  540,  540,  540,  540,  540,  540,  551,
 /*   110 */   -72, -106, -106, -106,  130,  252,  468,  468,  192,  563,
 /*   120 */   150,  357,  540,  357,  540,  540,  540,  540,  540,  540,
 /*   130 */   540,  540,  540,  540,  540,  540,  540,  880,  214, -105,
 /*   140 */  -105, -105, -106, -106, -106,  249,  249,  320,  343,  411,
 /*   150 */   334,  477,  515,  542,  282,  529,  476,  538,  627,  540,
 /*   160 */   540,  578,  540,  540,  397,  540,  540,  404,  540,  540,
 /*   170 */   541,  404,  540,  540,  518,  518,  518,  540,  540,  541,
 /*   180 */   540,  540,  541,  540,  836,  587,  540,  540,  541,  540,
 /*   190 */   540,  540,  541,  540,  540,  540,  541,  541,  540,  540,
 /*   200 */   540,  540,  540,  540,  204,  876,  448,   91,  707,  707,
 /*   210 */   369,  876,  876,  951,  876,  876,  260,  884,  884, 1133,
 /*   220 */  1133, 1133, 1133, 1127, 1052, 1052, 1112, 1052, 1056, 1052,
 /*   230 */  -105, 1031, 1036, 1037, 1044, 1042, 1033, 1054, 1074, 1149,
 /*   240 */  1074, 1054, 1077, 1061, 1077, 1061, 1159, 1074, 1074, 1149,
 /*   250 */  1112, 1052, 1052, 1052, 1159, 1165, 1054, 1165, 1054, 1165,
 /*   260 */  1054, 1054, 1146, 1067, 1165, 1054, 1142, 1142, 1186, 1031,
 /*   270 */  1054, 1192, 1192, 1192, 1192, 1031, 1142, 1186, 1054, 1176,
 /*   280 */  1176, 1054, 1054, 1073, -106, -106, -106, -106, -106, -106,
 /*   290 */   317,  132,  629,  590,  794,  905,  851,  677,  972,  796,
 /*   300 */   936,  980,  944, 1027, 1055, 1058,  986, 1086, 1087, 1090,
 /*   310 */  1095, 1050, 1070,  992, 1229, 1211, 1200, 1190, 1217, 1124,
 /*   320 */  1125, 1126, 1128, 1223, 1225, 1226, 1151, 1139, 1230, 1237,
 /*   330 */  1231, 1232, 1233, 1236, 1135, 1235, 1140, 1238, 1136, 1240,
 /*   340 */  1241, 1150, 1242, 1220, 1246, 1247, 1249, 1250, 1222, 1251,
 /*   350 */  1175, 1168, 1257, 1258, 1253, 1177, 1243, 1244, 1255, 1245,
 /*   360 */  1144, 1181, 1262, 1277, 1282, 1183, 1218, 1219, 1169, 1275,
 /*   370 */  1182, 1281, 1184, 1280, 1185, 1195, 1178, 1283, 1179, 1284,
 /*   380 */  1292, 1252, 1171, 1174, 1289, 1309, 1310,
 /*    90 */   930,  930,  930,  -62,  -62,  -14,   27,   27,  -40,  270,
 /*   100 */   519,  496,  498,  498,  498,  498,  498,  498,  498,  548,
 /*   110 */   -72, -106, -106, -106,  130,  322,  471,  471,  192,  246,
 /*   120 */   647,  127,  498,  127,  498,  498,  498,  498,  498,  498,
 /*   130 */   498,  498,  498,  498,  498,  498,  498,  286,  706, -105,
 /*   140 */  -105, -105, -106, -106, -106,  249,  249,  335,  205,  473,
 /*   150 */   479,  528,  536,  542,  333,  537,  486,  606,  689,  498,
 /*   160 */   498,  621,  498,  498,  463,  498,  498,  797,  498,  498,
 /*   170 */   512,  797,  498,  498,  554,  554,  554,  498,  498,  512,
 /*   180 */   498,  498,  512,  498,  748,  640,  498,  498,  512,  498,
 /*   190 */   498,  498,  512,  498,  498,  498,  512,  512,  498,  498,
 /*   200 */   498,  498,  498,  498,  204,  786,  796,  780,  780,  737,
 /*   210 */   937,  937,  937,  312,  937,  937,  811,   65,   65, 1136,
 /*   220 */  1136, 1136, 1136, 1128, -105, 1032, 1036, 1037, 1041, 1042,
 /*   230 */  1031, 1052, 1070, 1146, 1070, 1052, 1073, 1057, 1073, 1057,
 /*   240 */  1075, 1075, 1137, 1075, 1081, 1075, 1164, 1070, 1070, 1146,
 /*   250 */  1137, 1075, 1075, 1075, 1164, 1173, 1052, 1173, 1052, 1173,
 /*   260 */  1052, 1052, 1169, 1077, 1173, 1052, 1149, 1149, 1193, 1032,
 /*   270 */  1052, 1202, 1202, 1202, 1202, 1032, 1149, 1193, 1052, 1187,
 /*   280 */  1187, 1052, 1052, 1090, -106, -106, -106, -106, -106, -106,
 /*   290 */   317,  289,  681,  723,  874,  881,  910,  936,  971,  984,
 /*   300 */   896,  870,  822, 1015, 1016, 1027,  908, 1030, 1055, 1058,
 /*   310 */  1087, 1050, 1088,  639, 1232, 1214, 1122, 1125, 1127, 1129,
 /*   320 */  1222, 1223, 1224, 1153, 1138, 1228, 1238, 1231, 1233, 1229,
 /*   330 */  1234, 1134, 1235, 1140, 1239, 1141, 1236, 1240, 1150, 1242,
 /*   340 */  1237, 1220, 1247, 1226, 1248, 1251, 1249, 1253, 1230, 1254,
 /*   350 */  1180, 1174, 1261, 1262, 1259, 1182, 1246, 1241, 1263, 1243,
 /*   360 */  1155, 1184, 1265, 1282, 1290, 1189, 1227, 1244, 1170, 1276,
 /*   370 */  1183, 1284, 1185, 1283, 1188, 1196, 1181, 1286, 1179, 1287,
 /*   380 */  1292, 1250, 1175, 1172, 1291, 1309, 1310,
};
#define YY_REDUCE_USE_DFLT (-218)
#define YY_REDUCE_MAX 289
static const short yy_reduce_ofst[] = {
 /*     0 */   -56,  276,   -2,  -19,  399,  269,   49,  271,  270,   14,
 /*    10 */  -147,  -78,  273,  338,  340,  342,   44,  544,  263,  -60,
 /*    20 */    32,  144,  349, -217, -217, -217, -217, -217, -217, -217,
 /*     0 */   -56,  276,   -2,  -19,  399,  272,   49,  336,  330,   14,
 /*    10 */  -147,  -78,  202,  134,  346,  348,   43,  544,  285,  -60,
 /*    20 */    32,  271,  325, -217, -217, -217, -217, -217, -217, -217,
 /*    30 */  -217, -217, -217, -217, -217, -217, -217, -217, -217, -217,
 /*    40 */  -217, -217, -217, -217, -217, -217, -217, -217, -217, -217,
 /*    50 */  -217, -217, -217, -217,  405,  482,  485,  525,  568,  654,
 /*    60 */   697,  710,  712,  714,  721,  726,  747,  752,  754,  760,
 /*    70 */   763,  768,  792,  802,  804,  806,  809,  844,  853,  855,
 /*    80 */   857,  859,  873,  883,  892,  897,  900,  903,  918,  924,
 /*    90 */   928,  931,  933, -217, -217,  127, -217, -217, -217, -217,
 /*   100 */   454,  147,  509,  550,  554,  592,  593,  543,  489, -139,
 /*   110 */  -217, -217, -217, -217,   45,   21,   67,  120,  110,  110,
 /*   120 */     3,  389,  440,  573,  545,  594,  667,  675,  669,  595,
 /*   130 */   597,  637,  640,  716,  718,  679,  753,  293,  765,  770,
 /*   140 */   803,  843,  628,  576,  588, -112,  -83,   18,  154,  287,
 /*   150 */   302,  287,  287,   71,  339,  410,  423,  432,  494,  625,
 /*   160 */   641,  630,  432,  742,  732,  761,  766,  737,  839,  860,
 /*   170 */   287,  737,  868,  893,  867,  882,  886,  934,  935,  287,
 /*   180 */   945,  949,  287,  952,  852,  872,  963,  965,  287,  966,
 /*   190 */   968,  970,  287,  973,  974,  975,  287,  287,  976,  977,
 /*   200 */   978,  979,  981,  982,  983,  955,  939,  938,  906,  907,
 /*   210 */   910,  964,  967,  960,  969,  971,  984,  946,  948,  998,
 /*   220 */   999, 1000, 1001,  995,  987,  988,  989,  990,  991,  994,
 /*   230 */   993,  961,  996,  997, 1002, 1003,  947, 1015,  962, 1012,
 /*   240 */  1004, 1022, 1005, 1006, 1008, 1009, 1007, 1010, 1011, 1018,
 /*   250 */  1013, 1014, 1016, 1017, 1020, 1029, 1032, 1035, 1038, 1045,
 /*   260 */  1043, 1046,  956, 1019, 1049, 1051, 1021, 1023, 1024, 1025,
 /*   270 */  1064, 1026, 1030, 1039, 1040, 1034, 1041, 1028, 1066, 1047,
 /*   280 */  1048, 1068, 1071, 1053, 1065, 1057, 1059, 1060, 1062, 1063,
 /*    50 */  -217, -217, -217, -217,  469,  484,  568,  710,  712,  714,
 /*    60 */   719,  721,  726,  747,  752,  754,  760,  763,  768,  792,
 /*    70 */   802,  804,  806,  809,  844,  853,  855,  857,  859,  873,
 /*    80 */   883,  892,  897,  900,  903,  918,  924,  928,  931,  933,
 /*    90 */   935,  944,  952, -217, -217,  408, -217, -217, -217, -217,
 /*   100 */   -32,  219,  153,  332,  503,  505,  508,  583,  476, -139,
 /*   110 */  -217, -217, -217, -217,  141,   21,   19,   67,  313,  313,
 /*   120 */   299,  145,  230,  426,  223,  595,  483,  430,  667,  597,
 /*   130 */   627,  631,  637,  675,  676,  588,  677,   -5,  460,  671,
 /*   140 */   751,  765,  628,  487,  589, -112,  -57,   18,  143,  118,
 /*   150 */   213,  118,  118,  244,  331,  352,  416,  480,  527,  545,
 /*   160 */   626,  596,  480,  697,  832,  794,  851,  625,  860,  864,
 /*   170 */   118,  625,  868,  885,  862,  867,  882,  916,  917,  118,
 /*   180 */   934,  942,  118,  945,  852,  878,  949,  964,  118,  965,
 /*   190 */   968,  969,  118,  970,  973,  976,  118,  118,  977,  978,
 /*   200 */   979,  980,  981,  982,  983,  939,  938,  905,  906,  912,
 /*   210 */   966,  967,  972,  959,  974,  975,  986,  943,  946,  996,
 /*   220 */   997,  999, 1002,  998,  961,  957,  960,  962,  963,  987,
 /*   230 */   941, 1013,  956, 1009,  988, 1018,  989,  990,  992,  993,
 /*   240 */  1003, 1004, 1000, 1006, 1007, 1010, 1012,  991,  994, 1023,
 /*   250 */  1005, 1017, 1019, 1020, 1026, 1038, 1040, 1043, 1045, 1053,
 /*   260 */  1049, 1051,  995, 1001, 1059, 1056, 1028, 1029, 1008, 1021,
 /*   270 */  1062, 1033, 1034, 1035, 1039, 1024, 1046, 1014, 1065, 1011,
 /*   280 */  1022, 1072, 1079, 1025, 1066, 1061, 1063, 1044, 1047, 1048,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */   592,  819,  896,  707,  896,  819,  896,  819,  896,  711,
 /*    10 */   870,  815,  819,  896,  896,  896,  790,  896,  841,  896,
 /*    20 */   623,  841,  841,  742,  896,  896,  896,  896,  896,  896,
 /*    30 */   896,  896,  743,  896,  818,  814,  810,  812,  811,  744,
 /*    40 */   731,  740,  747,  723,  855,  749,  750,  756,  757,  871,

 /*   130 */   896,  896,  896,  896,  896,  896,  896,  896,  896,  896,
 /*   140 */   896,  896,  701,  711,  889,  896,  896,  667,  896,  896,
 /*   150 */   896,  896,  896,  896,  896,  896,  896,  896,  599,  597,
 /*   160 */   896,  699,  896,  896,  625,  896,  896,  709,  896,  896,
 /*   170 */   714,  715,  896,  896,  896,  896,  896,  896,  896,  613,
 /*   180 */   896,  896,  688,  896,  847,  896,  896,  896,  862,  896,
 /*   190 */   896,  896,  860,  896,  896,  896,  690,  752,  829,  896,
 /*   200 */   896,  875,  877,  896,  896,  734,  699,  708,  896,  896,
 /*   210 */   813,  734,  734,  646,  734,  734,  649,  746,  746,  596,
 /*   220 */   596,  596,  596,  666,  678,  678,  663,  678,  649,  678,
 /*   230 */   896,  746,  737,  739,  727,  741,  896,  716,  735,  896,
 /*   240 */   735,  716,  724,  726,  724,  726,  823,  735,  735,  896,
 /*   200 */   896,  875,  877,  896,  896,  699,  708,  896,  896,  813,
 /*   210 */   734,  734,  734,  646,  734,  734,  649,  746,  746,  596,
 /*   220 */   596,  596,  596,  666,  896,  746,  737,  739,  727,  741,
 /*   230 */   896,  716,  735,  896,  735,  716,  724,  726,  724,  726,
 /*   240 */   678,  678,  663,  678,  649,  678,  823,  735,  735,  896,
 /*   250 */   663,  678,  678,  678,  823,  608,  716,  608,  716,  608,
 /*   260 */   716,  716,  851,  854,  608,  716,  680,  680,  758,  746,
 /*   270 */   716,  687,  687,  687,  687,  746,  680,  758,  716,  873,
 /*   280 */   873,  716,  716,  882,  633,  651,  651,  857,  889,  894,
 /*   290 */   896,  896,  896,  896,  896,  896,  765,  896,  896,  896,
 /*   290 */   896,  896,  896,  896,  765,  896,  896,  896,  896,  896,
 /*   300 */   896,  896,  896,  896,  896,  896,  896,  896,  896,  896,
 /*   310 */   896,  836,  896,  896,  896,  896,  896,  896,  896,  770,
 /*   320 */   766,  896,  767,  896,  896,  896,  896,  693,  896,  896,
 /*   330 */   896,  896,  896,  896,  896,  728,  896,  738,  896,  896,
 /*   310 */   896,  836,  896,  896,  896,  896,  770,  766,  896,  767,
 /*   320 */   896,  896,  896,  896,  693,  896,  896,  896,  896,  896,
 /*   330 */   896,  896,  728,  896,  738,  896,  896,  896,  896,  896,
 /*   340 */   896,  896,  896,  896,  896,  896,  896,  896,  896,  896,
 /*   350 */   896,  896,  896,  896,  896,  896,  896,  849,  850,  896,
 /*   360 */   896,  896,  896,  896,  896,  896,  896,  896,  896,  896,
 /*   370 */   896,  896,  896,  896,  896,  896,  896,  896,  896,  896,
 /*   380 */   896,  881,  896,  896,  884,  593,  896,  587,  590,  589,
 /*   390 */   591,  595,  598,  620,  621,  622,  600,  601,  602,  603,
 /*   400 */   604,  605,  606,  612,  614,  632,  634,  641,  679,  682,
 /*   400 */   604,  605,  606,  612,  614,  632,  634,  618,  636,  697,
 /*   410 */   683,  684,  865,  866,  867,  642,  661,  664,  665,  643,
 /*   420 */   650,  732,  733,  644,  697,  698,  762,  691,  692,  696,
 /*   430 */   764,  768,  769,  771,  772,  619,  626,  627,  630,  631,
 /*   440 */   837,  839,  838,  840,  629,  628,  773,  776,  785,  786,
 /*   450 */   788,  794,  800,  803,  787,  792,  793,  795,  799,  802,
 /*   460 */   694,  695,  806,  808,  809,  863,  864,  804,  816,  817,
 /*   470 */   717,  807,  791,  729,  618,  736,  730,  700,  710,  719,
 /*   480 */   720,  721,  722,  705,  706,  712,  725,  760,  761,  713,
 /*   490 */   702,  703,  704,  805,  763,  774,  775,  645,  652,  653,
 /*   500 */   654,  657,  658,  659,  660,  655,  656,  824,  825,  827,
 /*   410 */   698,  762,  691,  692,  696,  764,  768,  769,  771,  772,
 /*   420 */   619,  626,  627,  630,  631,  837,  839,  838,  840,  629,
 /*   430 */   628,  773,  776,  785,  786,  788,  794,  800,  803,  787,
 /*   440 */   792,  793,  795,  799,  802,  694,  695,  806,  808,  809,
 /*   450 */   863,  864,  865,  866,  867,  804,  816,  817,  717,  807,
 /*   460 */   791,  729,  732,  733,  736,  730,  700,  710,  719,  720,
 /*   470 */   721,  722,  705,  706,  712,  725,  760,  761,  713,  702,
 /*   480 */   703,  704,  805,  763,  774,  775,  637,  638,  770,  639,
 /*   490 */   640,  641,  679,  682,  683,  684,  642,  661,  664,  665,
 /*   500 */   643,  650,  644,  645,  652,  653,  654,  657,  658,  659,
 /*   510 */   660,  655,  656,  824,  825,  827,  826,  647,  648,  662,
 /*   510 */   826,  647,  648,  662,  635,  636,  637,  638,  770,  639,
 /*   520 */   640,  624,  617,  668,  671,  672,  673,  674,  675,  677,
 /*   520 */   635,  624,  617,  668,  671,  672,  673,  674,  675,  677,
 /*   530 */   669,  670,  615,  607,  609,  718,  843,  852,  853,  848,
 /*   540 */   844,  845,  846,  610,  820,  821,  681,  754,  755,  842,
 /*   550 */   856,  858,  759,  859,  861,  886,  685,  686,  689,  828,
 /*   560 */   868,  745,  748,  751,  753,  830,  831,  832,  833,  834,
 /*   570 */   835,  869,  872,  876,  878,  879,  880,  883,  885,  890,
 /*   580 */   891,  892,  895,  893,  594,  588,
};

 /*  43 */ "typename ::= typename ids",
 /*  44 */ "signed ::= plus_num",
 /*  45 */ "signed ::= minus_num",
 /*  46 */ "carglist ::= carglist carg",
 /*  47 */ "carglist ::=",
 /*  48 */ "carg ::= CONSTRAINT nm ccons",
 /*  49 */ "carg ::= ccons",
 /*  50 */ "carg ::= DEFAULT term",
 /*  51 */ "carg ::= DEFAULT LP expr RP",
 /*  52 */ "carg ::= DEFAULT PLUS term",
 /*  53 */ "carg ::= DEFAULT MINUS term",
 /*  54 */ "carg ::= DEFAULT id",
 /*  50 */ "ccons ::= DEFAULT term",
 /*  51 */ "ccons ::= DEFAULT LP expr RP",
 /*  52 */ "ccons ::= DEFAULT PLUS term",
 /*  53 */ "ccons ::= DEFAULT MINUS term",
 /*  54 */ "ccons ::= DEFAULT id",
 /*  55 */ "ccons ::= NULL onconf",
 /*  56 */ "ccons ::= NOT NULL onconf",
 /*  57 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
 /*  58 */ "ccons ::= UNIQUE onconf",
 /*  59 */ "ccons ::= CHECK LP expr RP",
 /*  60 */ "ccons ::= REFERENCES nm idxlist_opt refargs",
 /*  61 */ "ccons ::= defer_subclause",

    case 205:
    case 211:
    case 219:
    case 222:
    case 224:
    case 225:
    case 235:
#line 633 "parse.y"
#line 618 "parse.y"
{sqlite3ExprDelete((yypminor->yy172));}
#line 1264 "parse.c"
      break;
    case 175:
    case 183:
    case 193:
    case 196:
    case 198:
    case 200:
    case 210:
    case 213:
    case 214:
    case 217:
    case 223:
#line 870 "parse.y"
#line 855 "parse.y"
{sqlite3ExprListDelete((yypminor->yy174));}
#line 1279 "parse.c"
      break;
    case 189:
    case 194:
    case 202:
    case 203:
#line 502 "parse.y"
#line 487 "parse.y"
{sqlite3SrcListDelete((yypminor->yy373));}
#line 1287 "parse.c"
      break;
    case 199:
#line 563 "parse.y"
#line 548 "parse.y"
{
  sqlite3ExprDelete((yypminor->yy234).pLimit);
  sqlite3ExprDelete((yypminor->yy234).pOffset);
}
#line 1295 "parse.c"
      break;
    case 206:
    case 209:
    case 216:
#line 519 "parse.y"
#line 504 "parse.y"
{sqlite3IdListDelete((yypminor->yy432));}
#line 1302 "parse.c"
      break;
    case 231:
    case 236:
#line 966 "parse.y"
#line 951 "parse.y"
{sqlite3DeleteTriggerStep((yypminor->yy243));}
#line 1308 "parse.c"
      break;
    case 233:
#line 950 "parse.y"
#line 935 "parse.y"
{sqlite3IdListDelete((yypminor->yy370).b);}
#line 1313 "parse.c"
      break;
    case 238:
#line 1034 "parse.y"
#line 1019 "parse.y"
{sqlite3ExprDelete((yypminor->yy386));}
#line 1318 "parse.c"
      break;
    default:  break;   /* If no destructor action specified: do nothing */
  }
}

  { 164, 2 },
  { 165, 1 },
  { 165, 1 },
  { 160, 2 },
  { 160, 0 },
  { 168, 3 },
  { 168, 1 },
  { 168, 2 },
  { 168, 4 },
  { 168, 3 },
  { 168, 3 },
  { 168, 2 },
  { 169, 2 },
  { 169, 4 },
  { 169, 3 },
  { 169, 3 },
  { 169, 2 },
  { 169, 2 },
  { 169, 3 },
  { 169, 5 },
  { 169, 2 },
  { 169, 4 },
  { 169, 4 },
  { 169, 1 },

      case 122:
#line 446 "parse.y"
{yygotominor.yy373 = sqliteMalloc(sizeof(*yygotominor.yy373));}
#line 2322 "parse.c"
        break;
      case 123:
#line 447 "parse.y"
{
{yygotominor.yy373 = yymsp[0].minor.yy373;}
#line 2327 "parse.c"
  yygotominor.yy373 = yymsp[0].minor.yy373;
  sqlite3SrcListShiftJoinType(yygotominor.yy373);
}
#line 2330 "parse.c"
        break;
      case 124:
#line 452 "parse.y"
#line 455 "parse.y"
{
   yygotominor.yy373 = yymsp[-1].minor.yy373;
   if( yygotominor.yy373 && yygotominor.yy373->nSrc>0 ) yygotominor.yy373->a[yygotominor.yy373->nSrc-1].jointype = yymsp[0].minor.yy46;
}
#line 2335 "parse.c"
#line 2338 "parse.c"
        break;
      case 125:
#line 456 "parse.y"
#line 459 "parse.y"
{yygotominor.yy373 = 0;}
#line 2340 "parse.c"
#line 2343 "parse.c"
        break;
      case 126:
#line 457 "parse.y"
#line 460 "parse.y"
{
  yygotominor.yy373 = sqlite3SrcListAppend(yymsp[-5].minor.yy373,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410);
  yygotominor.yy373 = sqlite3SrcListAppendFromTerm(yymsp[-5].minor.yy373,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,0,yymsp[-1].minor.yy172,yymsp[0].minor.yy432);
  if( yymsp[-2].minor.yy410.n ) sqlite3SrcListAddAlias(yygotominor.yy373,&yymsp[-2].minor.yy410);
  if( yymsp[-1].minor.yy172 ){
    if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pOn = yymsp[-1].minor.yy172; }
    else { sqlite3ExprDelete(yymsp[-1].minor.yy172); }
  }
}
  if( yymsp[0].minor.yy432 ){
    if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pUsing = yymsp[0].minor.yy432; }
    else { sqlite3IdListDelete(yymsp[0].minor.yy432); }
  }
}
#line 2356 "parse.c"
#line 2350 "parse.c"
        break;
      case 127:
#line 471 "parse.y"
#line 465 "parse.y"
{
    yygotominor.yy373 = sqlite3SrcListAppend(yymsp[-6].minor.yy373,0,0);
    yygotominor.yy373 = sqlite3SrcListAppendFromTerm(yymsp[-6].minor.yy373,0,0,&yymsp[-2].minor.yy410,yymsp[-4].minor.yy219,yymsp[-1].minor.yy172,yymsp[0].minor.yy432);
    if( yygotominor.yy373 && yygotominor.yy373->nSrc>0 ) yygotominor.yy373->a[yygotominor.yy373->nSrc-1].pSelect = yymsp[-4].minor.yy219;
    if( yymsp[-2].minor.yy410.n ) sqlite3SrcListAddAlias(yygotominor.yy373,&yymsp[-2].minor.yy410);
    if( yymsp[-1].minor.yy172 ){
      if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pOn = yymsp[-1].minor.yy172; }
      else { sqlite3ExprDelete(yymsp[-1].minor.yy172); }
    }
  }
    if( yymsp[0].minor.yy432 ){
      if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pUsing = yymsp[0].minor.yy432; }
      else { sqlite3IdListDelete(yymsp[0].minor.yy432); }
    }
  }
#line 2373 "parse.c"
#line 2357 "parse.c"
        break;
      case 129:
#line 492 "parse.y"
#line 476 "parse.y"
{
     sqlite3SrcListShiftJoinType(yymsp[0].minor.yy373);
     yygotominor.yy219 = sqlite3SelectNew(0,yymsp[0].minor.yy373,0,0,0,0,0,0,0);
  }
#line 2380 "parse.c"
#line 2365 "parse.c"
        break;
      case 130:
#line 498 "parse.y"
#line 483 "parse.y"
{yygotominor.yy410.z=0; yygotominor.yy410.n=0;}
#line 2385 "parse.c"
#line 2370 "parse.c"
        break;
      case 132:
#line 503 "parse.y"
#line 488 "parse.y"
{yygotominor.yy373 = sqlite3SrcListAppend(0,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410);}
#line 2390 "parse.c"
#line 2375 "parse.c"
        break;
      case 133:
#line 507 "parse.y"
#line 492 "parse.y"
{ yygotominor.yy46 = JT_INNER; }
#line 2395 "parse.c"
#line 2380 "parse.c"
        break;
      case 134:
#line 508 "parse.y"
#line 493 "parse.y"
{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
#line 2400 "parse.c"
#line 2385 "parse.c"
        break;
      case 135:
#line 509 "parse.y"
#line 494 "parse.y"
{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy410,0); }
#line 2405 "parse.c"
#line 2390 "parse.c"
        break;
      case 136:
#line 511 "parse.y"
#line 496 "parse.y"
{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy410,&yymsp[-1].minor.yy410); }
#line 2410 "parse.c"
#line 2395 "parse.c"
        break;
      case 137:
      case 145:
      case 154:
      case 161:
      case 176:
      case 203:
      case 226:
      case 228:
      case 232:
#line 515 "parse.y"
#line 500 "parse.y"
{yygotominor.yy172 = yymsp[0].minor.yy172;}
#line 2423 "parse.c"
#line 2408 "parse.c"
        break;
      case 138:
      case 153:
      case 160:
      case 204:
      case 227:
      case 229:
      case 233:
#line 516 "parse.y"
#line 501 "parse.y"
{yygotominor.yy172 = 0;}
#line 2434 "parse.c"
#line 2419 "parse.c"
        break;
      case 139:
      case 173:
#line 520 "parse.y"
#line 505 "parse.y"
{yygotominor.yy432 = yymsp[-1].minor.yy432;}
#line 2440 "parse.c"
#line 2425 "parse.c"
        break;
      case 140:
      case 172:
#line 521 "parse.y"
#line 506 "parse.y"
{yygotominor.yy432 = 0;}
#line 2446 "parse.c"
#line 2431 "parse.c"
        break;
      case 142:
      case 152:
#line 532 "parse.y"
#line 517 "parse.y"
{yygotominor.yy174 = yymsp[0].minor.yy174;}
#line 2452 "parse.c"
#line 2437 "parse.c"
        break;
      case 143:
#line 533 "parse.y"
#line 518 "parse.y"
{
  yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174,yymsp[-2].minor.yy172,yymsp[-1].minor.yy410.n>0?&yymsp[-1].minor.yy410:0);
  if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46;
}
#line 2460 "parse.c"
#line 2445 "parse.c"
        break;
      case 144:
#line 537 "parse.y"
#line 522 "parse.y"
{
  yygotominor.yy174 = sqlite3ExprListAppend(0,yymsp[-2].minor.yy172,yymsp[-1].minor.yy410.n>0?&yymsp[-1].minor.yy410:0);
  if( yygotominor.yy174 && yygotominor.yy174->a ) yygotominor.yy174->a[0].sortOrder = yymsp[0].minor.yy46;
}
#line 2468 "parse.c"
#line 2453 "parse.c"
        break;
      case 146:
      case 148:
#line 546 "parse.y"
#line 531 "parse.y"
{yygotominor.yy46 = SQLITE_SO_ASC;}
#line 2474 "parse.c"
#line 2459 "parse.c"
        break;
      case 147:
#line 547 "parse.y"
#line 532 "parse.y"
{yygotominor.yy46 = SQLITE_SO_DESC;}
#line 2479 "parse.c"
#line 2464 "parse.c"
        break;
      case 149:
#line 549 "parse.y"
#line 534 "parse.y"
{yygotominor.yy410.z = 0; yygotominor.yy410.n = 0;}
#line 2484 "parse.c"
#line 2469 "parse.c"
        break;
      case 155:
#line 567 "parse.y"
#line 552 "parse.y"
{yygotominor.yy234.pLimit = 0; yygotominor.yy234.pOffset = 0;}
#line 2489 "parse.c"
#line 2474 "parse.c"
        break;
      case 156:
#line 568 "parse.y"
#line 553 "parse.y"
{yygotominor.yy234.pLimit = yymsp[0].minor.yy172; yygotominor.yy234.pOffset = 0;}
#line 2494 "parse.c"
#line 2479 "parse.c"
        break;
      case 157:
#line 570 "parse.y"
#line 555 "parse.y"
{yygotominor.yy234.pLimit = yymsp[-2].minor.yy172; yygotominor.yy234.pOffset = yymsp[0].minor.yy172;}
#line 2499 "parse.c"
#line 2484 "parse.c"
        break;
      case 158:
#line 572 "parse.y"
#line 557 "parse.y"
{yygotominor.yy234.pOffset = yymsp[-2].minor.yy172; yygotominor.yy234.pLimit = yymsp[0].minor.yy172;}
#line 2504 "parse.c"
#line 2489 "parse.c"
        break;
      case 159:
#line 576 "parse.y"
#line 561 "parse.y"
{sqlite3DeleteFrom(pParse,yymsp[-1].minor.yy373,yymsp[0].minor.yy172);}
#line 2509 "parse.c"
#line 2494 "parse.c"
        break;
      case 162:
#line 587 "parse.y"
#line 572 "parse.y"
{sqlite3Update(pParse,yymsp[-3].minor.yy373,yymsp[-1].minor.yy174,yymsp[0].minor.yy172,yymsp[-4].minor.yy46);}
#line 2514 "parse.c"
#line 2499 "parse.c"
        break;
      case 163:
#line 593 "parse.y"
#line 578 "parse.y"
{yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174,yymsp[0].minor.yy172,&yymsp[-2].minor.yy410);}
#line 2519 "parse.c"
#line 2504 "parse.c"
        break;
      case 164:
#line 594 "parse.y"
#line 579 "parse.y"
{yygotominor.yy174 = sqlite3ExprListAppend(0,yymsp[0].minor.yy172,&yymsp[-2].minor.yy410);}
#line 2524 "parse.c"
#line 2509 "parse.c"
        break;
      case 165:
#line 600 "parse.y"
#line 585 "parse.y"
{sqlite3Insert(pParse, yymsp[-5].minor.yy373, yymsp[-1].minor.yy174, 0, yymsp[-4].minor.yy432, yymsp[-7].minor.yy46);}
#line 2529 "parse.c"
#line 2514 "parse.c"
        break;
      case 166:
#line 602 "parse.y"
#line 587 "parse.y"
{sqlite3Insert(pParse, yymsp[-2].minor.yy373, 0, yymsp[0].minor.yy219, yymsp[-1].minor.yy432, yymsp[-4].minor.yy46);}
#line 2534 "parse.c"
#line 2519 "parse.c"
        break;
      case 167:
#line 604 "parse.y"
#line 589 "parse.y"
{sqlite3Insert(pParse, yymsp[-3].minor.yy373, 0, 0, yymsp[-2].minor.yy432, yymsp[-5].minor.yy46);}
#line 2539 "parse.c"
#line 2524 "parse.c"
        break;
      case 170:
      case 230:
#line 614 "parse.y"
#line 599 "parse.y"
{yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-2].minor.yy174,yymsp[0].minor.yy172,0);}
#line 2545 "parse.c"
#line 2530 "parse.c"
        break;
      case 171:
      case 231:
#line 615 "parse.y"
#line 600 "parse.y"
{yygotominor.yy174 = sqlite3ExprListAppend(0,yymsp[0].minor.yy172,0);}
#line 2551 "parse.c"
#line 2536 "parse.c"
        break;
      case 174:
#line 624 "parse.y"
#line 609 "parse.y"
{yygotominor.yy432 = sqlite3IdListAppend(yymsp[-2].minor.yy432,&yymsp[0].minor.yy410);}
#line 2556 "parse.c"
#line 2541 "parse.c"
        break;
      case 175:
#line 625 "parse.y"
#line 610 "parse.y"
{yygotominor.yy432 = sqlite3IdListAppend(0,&yymsp[0].minor.yy410);}
#line 2561 "parse.c"
#line 2546 "parse.c"
        break;
      case 177:
#line 636 "parse.y"
#line 621 "parse.y"
{yygotominor.yy172 = yymsp[-1].minor.yy172; sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); }
#line 2566 "parse.c"
#line 2551 "parse.c"
        break;
      case 178:
      case 183:
      case 184:
#line 637 "parse.y"
#line 622 "parse.y"
{yygotominor.yy172 = sqlite3Expr(yymsp[0].major, 0, 0, &yymsp[0].minor.yy0);}
#line 2573 "parse.c"
#line 2558 "parse.c"
        break;
      case 179:
      case 180:
#line 638 "parse.y"
#line 623 "parse.y"
{yygotominor.yy172 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy0);}
#line 2579 "parse.c"
#line 2564 "parse.c"
        break;
      case 181:
#line 640 "parse.y"
#line 625 "parse.y"
{
  Expr *temp1 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy410);
  Expr *temp2 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy410);
  yygotominor.yy172 = sqlite3Expr(TK_DOT, temp1, temp2, 0);
}
#line 2588 "parse.c"
#line 2573 "parse.c"
        break;
      case 182:
#line 645 "parse.y"
#line 630 "parse.y"
{
  Expr *temp1 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-4].minor.yy410);
  Expr *temp2 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy410);
  Expr *temp3 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy410);
  Expr *temp4 = sqlite3Expr(TK_DOT, temp2, temp3, 0);
  yygotominor.yy172 = sqlite3Expr(TK_DOT, temp1, temp4, 0);
}
#line 2599 "parse.c"
#line 2584 "parse.c"
        break;
      case 185:
#line 654 "parse.y"
#line 639 "parse.y"
{yygotominor.yy172 = sqlite3RegisterExpr(pParse, &yymsp[0].minor.yy0);}
#line 2604 "parse.c"
#line 2589 "parse.c"
        break;
      case 186:
#line 655 "parse.y"
#line 640 "parse.y"
{
  Token *pToken = &yymsp[0].minor.yy0;
  Expr *pExpr = yygotominor.yy172 = sqlite3Expr(TK_VARIABLE, 0, 0, pToken);
  sqlite3ExprAssignVarNumber(pParse, pExpr);
}
#line 2613 "parse.c"
#line 2598 "parse.c"
        break;
      case 187:
#line 661 "parse.y"
#line 646 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_CAST, yymsp[-3].minor.yy172, 0, &yymsp[-1].minor.yy410);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
}
#line 2621 "parse.c"
#line 2606 "parse.c"
        break;
      case 188:
#line 666 "parse.y"
#line 651 "parse.y"
{
  yygotominor.yy172 = sqlite3ExprFunction(yymsp[-1].minor.yy174, &yymsp[-4].minor.yy0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
  if( yymsp[-2].minor.yy46 && yygotominor.yy172 ){
    yygotominor.yy172->flags |= EP_Distinct;
  }
}
#line 2632 "parse.c"
#line 2617 "parse.c"
        break;
      case 189:
#line 673 "parse.y"
#line 658 "parse.y"
{
  yygotominor.yy172 = sqlite3ExprFunction(0, &yymsp[-3].minor.yy0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
}
#line 2640 "parse.c"
#line 2625 "parse.c"
        break;
      case 190:
#line 677 "parse.y"
#line 662 "parse.y"
{
  /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
  ** treated as functions that return constants */
  yygotominor.yy172 = sqlite3ExprFunction(0,&yymsp[0].minor.yy0);
  if( yygotominor.yy172 ){
    yygotominor.yy172->op = TK_CONST_FUNC;  
    yygotominor.yy172->span = yymsp[0].minor.yy0;
  }
}
#line 2653 "parse.c"
#line 2638 "parse.c"
        break;
      case 191:
      case 192:
      case 193:
      case 194:
      case 195:
      case 196:
      case 197:
      case 198:
#line 686 "parse.y"
#line 671 "parse.y"
{yygotominor.yy172 = sqlite3Expr(yymsp[-1].major, yymsp[-2].minor.yy172, yymsp[0].minor.yy172, 0);}
#line 2665 "parse.c"
#line 2650 "parse.c"
        break;
      case 199:
      case 201:
#line 696 "parse.y"
#line 681 "parse.y"
{yygotominor.yy72.eOperator = yymsp[0].minor.yy0; yygotominor.yy72.not = 0;}
#line 2671 "parse.c"
#line 2656 "parse.c"
        break;
      case 200:
      case 202:
#line 697 "parse.y"
#line 682 "parse.y"
{yygotominor.yy72.eOperator = yymsp[0].minor.yy0; yygotominor.yy72.not = 1;}
#line 2677 "parse.c"
#line 2662 "parse.c"
        break;
      case 205:
#line 704 "parse.y"
#line 689 "parse.y"
{
  ExprList *pList;
  pList = sqlite3ExprListAppend(0, yymsp[-1].minor.yy172, 0);
  pList = sqlite3ExprListAppend(pList, yymsp[-3].minor.yy172, 0);
  if( yymsp[0].minor.yy172 ){
    pList = sqlite3ExprListAppend(pList, yymsp[0].minor.yy172, 0);
  }
  yygotominor.yy172 = sqlite3ExprFunction(pList, &yymsp[-2].minor.yy72.eOperator);
  if( yymsp[-2].minor.yy72.not ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172, &yymsp[-3].minor.yy172->span, &yymsp[-1].minor.yy172->span);
  if( yygotominor.yy172 ) yygotominor.yy172->flags |= EP_InfixFunc;
}
#line 2693 "parse.c"
#line 2678 "parse.c"
        break;
      case 206:
#line 717 "parse.y"
#line 702 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(yymsp[0].major, yymsp[-1].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy172->span,&yymsp[0].minor.yy0);
}
#line 2701 "parse.c"
#line 2686 "parse.c"
        break;
      case 207:
#line 721 "parse.y"
#line 706 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_ISNULL, yymsp[-2].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy172->span,&yymsp[0].minor.yy0);
}
#line 2709 "parse.c"
#line 2694 "parse.c"
        break;
      case 208:
#line 725 "parse.y"
#line 710 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_NOTNULL, yymsp[-2].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy172->span,&yymsp[0].minor.yy0);
}
#line 2717 "parse.c"
#line 2702 "parse.c"
        break;
      case 209:
#line 729 "parse.y"
#line 714 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_NOTNULL, yymsp[-3].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy172->span,&yymsp[0].minor.yy0);
}
#line 2725 "parse.c"
#line 2710 "parse.c"
        break;
      case 210:
#line 733 "parse.y"
#line 718 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(yymsp[-1].major, yymsp[0].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span);
}
#line 2733 "parse.c"
#line 2718 "parse.c"
        break;
      case 211:
#line 737 "parse.y"
#line 722 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_UMINUS, yymsp[0].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span);
}
#line 2741 "parse.c"
#line 2726 "parse.c"
        break;
      case 212:
#line 741 "parse.y"
#line 726 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_UPLUS, yymsp[0].minor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span);
}
#line 2749 "parse.c"
#line 2734 "parse.c"
        break;
      case 215:
#line 748 "parse.y"
#line 733 "parse.y"
{
  ExprList *pList = sqlite3ExprListAppend(0, yymsp[-2].minor.yy172, 0);
  pList = sqlite3ExprListAppend(pList, yymsp[0].minor.yy172, 0);
  yygotominor.yy172 = sqlite3Expr(TK_BETWEEN, yymsp[-4].minor.yy172, 0, 0);
  if( yygotominor.yy172 ){
    yygotominor.yy172->pList = pList;
  }else{
    sqlite3ExprListDelete(pList);
  } 
  if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0);
  sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy172->span);
}
#line 2765 "parse.c"
#line 2750 "parse.c"
        break;
      case 218:
#line 764 "parse.y"
#line 749 "parse.y"
{
    yygotominor.yy172 = sqlite3Expr(TK_IN, yymsp[-4].minor.yy172, 0, 0);
    if( yygotominor.yy172 ){
      yygotominor.yy172->pList = yymsp[-1].minor.yy174;
    }else{
      sqlite3ExprListDelete(yymsp[-1].minor.yy174);
    }
    if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0);
    sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy0);
  }
#line 2779 "parse.c"
#line 2764 "parse.c"
        break;
      case 219:
#line 774 "parse.y"
#line 759 "parse.y"
{
    yygotominor.yy172 = sqlite3Expr(TK_SELECT, 0, 0, 0);
    if( yygotominor.yy172 ){
      yygotominor.yy172->pSelect = yymsp[-1].minor.yy219;
    }else{
      sqlite3SelectDelete(yymsp[-1].minor.yy219);
    }
    sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
  }
#line 2792 "parse.c"
#line 2777 "parse.c"
        break;
      case 220:
#line 783 "parse.y"
#line 768 "parse.y"
{
    yygotominor.yy172 = sqlite3Expr(TK_IN, yymsp[-4].minor.yy172, 0, 0);
    if( yygotominor.yy172 ){
      yygotominor.yy172->pSelect = yymsp[-1].minor.yy219;
    }else{
      sqlite3SelectDelete(yymsp[-1].minor.yy219);
    }
    if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0);
    sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy0);
  }
#line 2806 "parse.c"
#line 2791 "parse.c"
        break;
      case 221:
#line 793 "parse.y"
#line 778 "parse.y"
{
    SrcList *pSrc = sqlite3SrcListAppend(0,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410);
    yygotominor.yy172 = sqlite3Expr(TK_IN, yymsp[-3].minor.yy172, 0, 0);
    if( yygotominor.yy172 ){
      yygotominor.yy172->pSelect = sqlite3SelectNew(0,pSrc,0,0,0,0,0,0,0);
    }else{
      sqlite3SrcListDelete(pSrc);
    }
    if( yymsp[-2].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0);
    sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy172->span,yymsp[0].minor.yy410.z?&yymsp[0].minor.yy410:&yymsp[-1].minor.yy410);
  }
#line 2821 "parse.c"
#line 2806 "parse.c"
        break;
      case 222:
#line 804 "parse.y"
#line 789 "parse.y"
{
    Expr *p = yygotominor.yy172 = sqlite3Expr(TK_EXISTS, 0, 0, 0);
    if( p ){
      p->pSelect = yymsp[-1].minor.yy219;
      sqlite3ExprSpan(p,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
    }else{
      sqlite3SelectDelete(yymsp[-1].minor.yy219);
    }
  }
#line 2834 "parse.c"
#line 2819 "parse.c"
        break;
      case 223:
#line 816 "parse.y"
#line 801 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_CASE, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, 0);
  if( yygotominor.yy172 ){
    yygotominor.yy172->pList = yymsp[-2].minor.yy174;
  }else{
    sqlite3ExprListDelete(yymsp[-2].minor.yy174);
  }
  sqlite3ExprSpan(yygotominor.yy172, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0);
}
#line 2847 "parse.c"
#line 2832 "parse.c"
        break;
      case 224:
#line 827 "parse.y"
#line 812 "parse.y"
{
  yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174, yymsp[-2].minor.yy172, 0);
  yygotominor.yy174 = sqlite3ExprListAppend(yygotominor.yy174, yymsp[0].minor.yy172, 0);
}
#line 2855 "parse.c"
#line 2840 "parse.c"
        break;
      case 225:
#line 831 "parse.y"
#line 816 "parse.y"
{
  yygotominor.yy174 = sqlite3ExprListAppend(0, yymsp[-2].minor.yy172, 0);
  yygotominor.yy174 = sqlite3ExprListAppend(yygotominor.yy174, yymsp[0].minor.yy172, 0);
}
#line 2863 "parse.c"
#line 2848 "parse.c"
        break;
      case 234:
#line 858 "parse.y"
#line 843 "parse.y"
{
  sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy410, &yymsp[-5].minor.yy410, sqlite3SrcListAppend(0,&yymsp[-3].minor.yy410,0), yymsp[-1].minor.yy174, yymsp[-9].minor.yy46,
                      &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy46);
}
#line 2871 "parse.c"
#line 2856 "parse.c"
        break;
      case 235:
      case 280:
#line 864 "parse.y"
#line 849 "parse.y"
{yygotominor.yy46 = OE_Abort;}
#line 2877 "parse.c"
#line 2862 "parse.c"
        break;
      case 236:
#line 865 "parse.y"
#line 850 "parse.y"
{yygotominor.yy46 = OE_None;}
#line 2882 "parse.c"
#line 2867 "parse.c"
        break;
      case 239:
#line 875 "parse.y"
#line 860 "parse.y"
{
  Expr *p = 0;
  if( yymsp[-1].minor.yy410.n>0 ){
    p = sqlite3Expr(TK_COLUMN, 0, 0, 0);
    if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)yymsp[-1].minor.yy410.z, yymsp[-1].minor.yy410.n);
  }
  yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174, p, &yymsp[-2].minor.yy410);
  if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46;
}
#line 2895 "parse.c"
#line 2880 "parse.c"
        break;
      case 240:
#line 884 "parse.y"
#line 869 "parse.y"
{
  Expr *p = 0;
  if( yymsp[-1].minor.yy410.n>0 ){
    p = sqlite3Expr(TK_COLUMN, 0, 0, 0);
    if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)yymsp[-1].minor.yy410.z, yymsp[-1].minor.yy410.n);
  }
  yygotominor.yy174 = sqlite3ExprListAppend(0, p, &yymsp[-2].minor.yy410);
  if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46;
}
#line 2908 "parse.c"
#line 2893 "parse.c"
        break;
      case 242:
#line 898 "parse.y"
#line 883 "parse.y"
{sqlite3DropIndex(pParse, yymsp[0].minor.yy373, yymsp[-1].minor.yy46);}
#line 2913 "parse.c"
#line 2898 "parse.c"
        break;
      case 243:
      case 244:
#line 903 "parse.y"
#line 888 "parse.y"
{sqlite3Vacuum(pParse);}
#line 2919 "parse.c"
#line 2904 "parse.c"
        break;
      case 245:
      case 247:
#line 910 "parse.y"
#line 895 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy410,0);}
#line 2925 "parse.c"
#line 2910 "parse.c"
        break;
      case 246:
#line 911 "parse.y"
#line 896 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy0,0);}
#line 2930 "parse.c"
#line 2915 "parse.c"
        break;
      case 248:
#line 913 "parse.y"
#line 898 "parse.y"
{
  sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy410,1);
}
#line 2937 "parse.c"
#line 2922 "parse.c"
        break;
      case 249:
#line 916 "parse.y"
#line 901 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410,&yymsp[-1].minor.yy410,0);}
#line 2942 "parse.c"
#line 2927 "parse.c"
        break;
      case 250:
#line 917 "parse.y"
#line 902 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410,0,0);}
#line 2947 "parse.c"
#line 2932 "parse.c"
        break;
      case 256:
#line 929 "parse.y"
#line 914 "parse.y"
{
  Token all;
  all.z = yymsp[-3].minor.yy410.z;
  all.n = (yymsp[0].minor.yy0.z - yymsp[-3].minor.yy410.z) + yymsp[0].minor.yy0.n;
  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy243, &all);
}
#line 2957 "parse.c"
#line 2942 "parse.c"
        break;
      case 257:
#line 938 "parse.y"
#line 923 "parse.y"
{
  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy410, &yymsp[-6].minor.yy410, yymsp[-5].minor.yy46, yymsp[-4].minor.yy370.a, yymsp[-4].minor.yy370.b, yymsp[-2].minor.yy373, yymsp[-1].minor.yy46, yymsp[0].minor.yy172, yymsp[-10].minor.yy46, yymsp[-8].minor.yy46);
  yygotominor.yy410 = (yymsp[-6].minor.yy410.n==0?yymsp[-7].minor.yy410:yymsp[-6].minor.yy410);
}
#line 2965 "parse.c"
#line 2950 "parse.c"
        break;
      case 258:
      case 261:
#line 944 "parse.y"
#line 929 "parse.y"
{ yygotominor.yy46 = TK_BEFORE; }
#line 2971 "parse.c"
#line 2956 "parse.c"
        break;
      case 259:
#line 945 "parse.y"
#line 930 "parse.y"
{ yygotominor.yy46 = TK_AFTER;  }
#line 2976 "parse.c"
#line 2961 "parse.c"
        break;
      case 260:
#line 946 "parse.y"
#line 931 "parse.y"
{ yygotominor.yy46 = TK_INSTEAD;}
#line 2981 "parse.c"
#line 2966 "parse.c"
        break;
      case 262:
      case 263:
#line 951 "parse.y"
#line 936 "parse.y"
{yygotominor.yy370.a = yymsp[0].major; yygotominor.yy370.b = 0;}
#line 2987 "parse.c"
#line 2972 "parse.c"
        break;
      case 264:
#line 953 "parse.y"
#line 938 "parse.y"
{yygotominor.yy370.a = TK_UPDATE; yygotominor.yy370.b = yymsp[0].minor.yy432;}
#line 2992 "parse.c"
#line 2977 "parse.c"
        break;
      case 265:
      case 266:
#line 956 "parse.y"
#line 941 "parse.y"
{ yygotominor.yy46 = TK_ROW; }
#line 2998 "parse.c"
#line 2983 "parse.c"
        break;
      case 267:
#line 958 "parse.y"
#line 943 "parse.y"
{ yygotominor.yy46 = TK_STATEMENT; }
#line 3003 "parse.c"
#line 2988 "parse.c"
        break;
      case 268:
#line 962 "parse.y"
#line 947 "parse.y"
{ yygotominor.yy172 = 0; }
#line 3008 "parse.c"
#line 2993 "parse.c"
        break;
      case 269:
#line 963 "parse.y"
#line 948 "parse.y"
{ yygotominor.yy172 = yymsp[0].minor.yy172; }
#line 3013 "parse.c"
#line 2998 "parse.c"
        break;
      case 270:
#line 967 "parse.y"
#line 952 "parse.y"
{
  if( yymsp[-2].minor.yy243 ){
    yymsp[-2].minor.yy243->pLast->pNext = yymsp[-1].minor.yy243;
  }else{
    yymsp[-2].minor.yy243 = yymsp[-1].minor.yy243;
  }
  yymsp[-2].minor.yy243->pLast = yymsp[-1].minor.yy243;
  yygotominor.yy243 = yymsp[-2].minor.yy243;
}
#line 3026 "parse.c"
#line 3011 "parse.c"
        break;
      case 271:
#line 976 "parse.y"
#line 961 "parse.y"
{ yygotominor.yy243 = 0; }
#line 3031 "parse.c"
#line 3016 "parse.c"
        break;
      case 272:
#line 982 "parse.y"
#line 967 "parse.y"
{ yygotominor.yy243 = sqlite3TriggerUpdateStep(&yymsp[-3].minor.yy410, yymsp[-1].minor.yy174, yymsp[0].minor.yy172, yymsp[-4].minor.yy46); }
#line 3036 "parse.c"
#line 3021 "parse.c"
        break;
      case 273:
#line 987 "parse.y"
#line 972 "parse.y"
{yygotominor.yy243 = sqlite3TriggerInsertStep(&yymsp[-5].minor.yy410, yymsp[-4].minor.yy432, yymsp[-1].minor.yy174, 0, yymsp[-7].minor.yy46);}
#line 3041 "parse.c"
#line 3026 "parse.c"
        break;
      case 274:
#line 990 "parse.y"
#line 975 "parse.y"
{yygotominor.yy243 = sqlite3TriggerInsertStep(&yymsp[-2].minor.yy410, yymsp[-1].minor.yy432, 0, yymsp[0].minor.yy219, yymsp[-4].minor.yy46);}
#line 3046 "parse.c"
#line 3031 "parse.c"
        break;
      case 275:
#line 994 "parse.y"
#line 979 "parse.y"
{yygotominor.yy243 = sqlite3TriggerDeleteStep(&yymsp[-1].minor.yy410, yymsp[0].minor.yy172);}
#line 3051 "parse.c"
#line 3036 "parse.c"
        break;
      case 276:
#line 997 "parse.y"
#line 982 "parse.y"
{yygotominor.yy243 = sqlite3TriggerSelectStep(yymsp[0].minor.yy219); }
#line 3056 "parse.c"
#line 3041 "parse.c"
        break;
      case 277:
#line 1000 "parse.y"
#line 985 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_RAISE, 0, 0, 0); 
  if( yygotominor.yy172 ){
    yygotominor.yy172->iColumn = OE_Ignore;
    sqlite3ExprSpan(yygotominor.yy172, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0);
  }
}
#line 3067 "parse.c"
#line 3052 "parse.c"
        break;
      case 278:
#line 1007 "parse.y"
#line 992 "parse.y"
{
  yygotominor.yy172 = sqlite3Expr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy410); 
  if( yygotominor.yy172 ) {
    yygotominor.yy172->iColumn = yymsp[-3].minor.yy46;
    sqlite3ExprSpan(yygotominor.yy172, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0);
  }
}
#line 3078 "parse.c"
#line 3063 "parse.c"
        break;
      case 279:
#line 1017 "parse.y"
#line 1002 "parse.y"
{yygotominor.yy46 = OE_Rollback;}
#line 3083 "parse.c"
#line 3068 "parse.c"
        break;
      case 281:
#line 1019 "parse.y"
#line 1004 "parse.y"
{yygotominor.yy46 = OE_Fail;}
#line 3088 "parse.c"
#line 3073 "parse.c"
        break;
      case 282:
#line 1024 "parse.y"
#line 1009 "parse.y"
{
  sqlite3DropTrigger(pParse,yymsp[0].minor.yy373,yymsp[-1].minor.yy46);
}
#line 3095 "parse.c"
#line 3080 "parse.c"
        break;
      case 283:
#line 1030 "parse.y"
#line 1015 "parse.y"
{
  sqlite3Attach(pParse, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, yymsp[0].minor.yy386);
}
#line 3102 "parse.c"
#line 3087 "parse.c"
        break;
      case 284:
#line 1035 "parse.y"
#line 1020 "parse.y"
{ yygotominor.yy386 = 0; }
#line 3107 "parse.c"
#line 3092 "parse.c"
        break;
      case 285:
#line 1036 "parse.y"
#line 1021 "parse.y"
{ yygotominor.yy386 = yymsp[0].minor.yy172; }
#line 3112 "parse.c"
#line 3097 "parse.c"
        break;
      case 288:
#line 1042 "parse.y"
#line 1027 "parse.y"
{
  sqlite3Detach(pParse, yymsp[0].minor.yy172);
}
#line 3119 "parse.c"
#line 3104 "parse.c"
        break;
      case 289:
#line 1048 "parse.y"
#line 1033 "parse.y"
{sqlite3Reindex(pParse, 0, 0);}
#line 3124 "parse.c"
#line 3109 "parse.c"
        break;
      case 290:
#line 1049 "parse.y"
#line 1034 "parse.y"
{sqlite3Reindex(pParse, &yymsp[-1].minor.yy410, &yymsp[0].minor.yy410);}
#line 3129 "parse.c"
#line 3114 "parse.c"
        break;
      case 291:
#line 1054 "parse.y"
#line 1039 "parse.y"
{sqlite3Analyze(pParse, 0, 0);}
#line 3134 "parse.c"
#line 3119 "parse.c"
        break;
      case 292:
#line 1055 "parse.y"
#line 1040 "parse.y"
{sqlite3Analyze(pParse, &yymsp[-1].minor.yy410, &yymsp[0].minor.yy410);}
#line 3139 "parse.c"
#line 3124 "parse.c"
        break;
      case 293:
#line 1060 "parse.y"
#line 1045 "parse.y"
{
  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy373,&yymsp[0].minor.yy410);
}
#line 3146 "parse.c"
#line 3131 "parse.c"
        break;
      case 294:
#line 1063 "parse.y"
#line 1048 "parse.y"
{
  sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy410);
}
#line 3153 "parse.c"
#line 3138 "parse.c"
        break;
      case 295:
#line 1066 "parse.y"
#line 1051 "parse.y"
{
  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy373);
}
#line 3160 "parse.c"
#line 3145 "parse.c"
        break;
      case 298:
#line 1075 "parse.y"
#line 1060 "parse.y"
{sqlite3VtabFinishParse(pParse,0);}
#line 3165 "parse.c"
#line 3150 "parse.c"
        break;
      case 299:
#line 1076 "parse.y"
#line 1061 "parse.y"
{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
#line 3170 "parse.c"
#line 3155 "parse.c"
        break;
      case 300:
#line 1077 "parse.y"
#line 1062 "parse.y"
{
    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy410, &yymsp[-2].minor.yy410, &yymsp[0].minor.yy410);
}
#line 3177 "parse.c"
#line 3162 "parse.c"
        break;
      case 303:
#line 1082 "parse.y"
#line 1067 "parse.y"
{sqlite3VtabArgInit(pParse);}
#line 3182 "parse.c"
#line 3167 "parse.c"
        break;
      case 305:
      case 306:
      case 307:
      case 309:
#line 1084 "parse.y"
#line 1069 "parse.y"
{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
#line 3190 "parse.c"
#line 3175 "parse.c"
        break;
  };
  yygoto = yyRuleInfo[yyruleno].lhs;
  yysize = yyRuleInfo[yyruleno].nrhs;
  yypParser->yyidx -= yysize;
  yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto);
  if( yyact < YYNSTATE ){