System.Data.SQLite

#pragma unmanaged
extern "C"
{

/*
** 2005 February 15
**
** 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 C code routines that used to generate VDBE code
** that implements the ALTER TABLE command.
**
** $Id: alter.c,v 1.6 2005/08/01 19:32:08 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.

  char *zName = 0;          /* NULL-terminated version of pName */ 
  sqlite3 *db = pParse->db; /* Database connection */
  Vdbe *v;
#ifndef SQLITE_OMIT_TRIGGER
  char *zWhere = 0;         /* Where clause to locate temp triggers */
#endif
  

  assert( pSrc->nSrc==1 );

  pTab = sqlite3LocateTable(pParse, pSrc->a[0].zName, pSrc->a[0].zDatabase);
  if( !pTab ) goto exit_rename_table;
  iDb = pTab->iDb;
  zDb = db->aDb[iDb].zName;

void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
  Table *pNew;
  Table *pTab;
  Vdbe *v;
  int iDb;
  int i;
  int nAlloc;


  /* Look up the table being altered. */
  assert( !pParse->pNewTable );

  pTab = sqlite3LocateTable(pParse, pSrc->a[0].zName, pSrc->a[0].zDatabase);
  if( !pTab ) goto exit_begin_add_column;

  /* Make sure this is not an attempt to ALTER a view. */
  if( pTab->pSelect ){
    sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
    goto exit_begin_add_column;
  }

  assert( pTab->addColOffset>0 );
  iDb = pTab->iDb;

  /* Put a copy of the Table struct in Parse.pNewTable for the
  ** sqlite3AddColumn() function and friends to modify.
  */
  pNew = (Table *)sqliteMalloc(sizeof(Table));
  if( !pNew ) goto exit_begin_add_column;
  pParse->pNewTable = pNew;

  pNew->nCol = pTab->nCol;
  assert( pNew->nCol>0 );
  nAlloc = (((pNew->nCol-1)/8)*8)+8;
  assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
  pNew->aCol = (Column *)sqliteMalloc(sizeof(Column)*nAlloc);
  pNew->zName = sqliteStrDup(pTab->zName);
  if( !pNew->aCol || !pNew->zName ){

  sqlite3ChangeCookie(pParse->db, v, iDb);

exit_begin_add_column:
  sqlite3SrcListDelete(pSrc);
  return;
}
#endif  /* SQLITE_ALTER_TABLE */

}

#pragma unmanaged
extern "C"
{
  /*
** 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.6 2005/08/01 19:32:08 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** This routine is called by the parser to process an ATTACH statement:
**
**     ATTACH DATABASE filename AS dbname

    int i = db->nDb - 1;
    assert( i>=2 );
    if( db->aDb[i].pBt ){
      sqlite3BtreeClose(db->aDb[i].pBt);
      db->aDb[i].pBt = 0;
    }
    sqlite3ResetInternalSchema(db, 0);
    if( 0==pParse->nErr ){
      pParse->nErr++;
      pParse->rc = SQLITE_ERROR;
    }
  }

attach_end:
  sqliteFree(zFile);
  sqliteFree(zName);

      return 1;
    }
    pStep = pStep->pNext;
  }
  return 0;
}
#endif

}

#pragma unmanaged
extern "C"
{
  /*
** 2003 January 11
**
** 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 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.6 2005/08/01 19:32:09 rmsimpson Exp $
*/
#include "sqliteInt.h"

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

  Table *pTab;          /* The table being read */
  const char *zCol;     /* Name of the column of the table */
  int iSrc;             /* Index in pTabList->a[] of table being read */
  const char *zDBase;   /* Name of database being accessed */
  TriggerStack *pStack; /* The stack of current triggers */

  if( db->xAuth==0 ) return;

  assert( pExpr->op==TK_COLUMN );
  for(iSrc=0; pTabList && iSrc<pTabList->nSrc; iSrc++){
    if( pExpr->iTable==pTabList->a[iSrc].iCursor ) break;
  }
  if( iSrc>=0 && pTabList && iSrc<pTabList->nSrc ){
    pTab = pTabList->a[iSrc].pTab;
  }else if( (pStack = pParse->trigStack)!=0 ){

  if( pContext->pParse ){
    pContext->pParse->zAuthContext = pContext->zAuthContext;
    pContext->pParse = 0;
  }
}

#endif /* SQLITE_OMIT_AUTHORIZATION */

}

#pragma unmanaged
extern "C"
{
  /*
** 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.7 2005/08/03 06:43:44 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.

/* Forward declarations */
typedef struct MemPage MemPage;

/*
** This is a magic string that appears at the beginning of every
** SQLite database in order to identify the file as a real database.









**                                  123456789 123456 */


static const char zMagicHeader[] = "SQLite format 3";

/*
** Page type flags.  An ORed combination of these flags appear as the
** first byte of every BTree page.
*/
#define PTF_INTKEY    0x01
#define PTF_ZERODATA  0x02

** This a more complex version of findCell() that works for
** pages that do contain overflow cells.  See insert
*/
static u8 *findOverflowCell(MemPage *pPage, int iCell){
  int i;
  for(i=pPage->nOverflow-1; i>=0; i--){
    int k;
	struct MemPage::_OvflCell *pOvfl;
    pOvfl = &pPage->aOvfl[i];
    k = pOvfl->idx;
    if( k<=iCell ){
      if( k==iCell ){
        return pOvfl->pCell;
      }
      iCell--;

** One or the other of the two processes must give way or there can be
** no progress.  By returning SQLITE_BUSY and not invoking the busy callback
** when A already has a read lock, we encourage A to give up and let B
** proceed.
*/
int sqlite3BtreeBeginTrans(Btree *pBt, int wrflag){
  int rc = SQLITE_OK;
  int busy = 0;
  BusyHandler *pH;

  /* If the btree is already in a write-transaction, or it
  ** is already in a read-transaction and a read-transaction
  ** is requested, this is a no-op.
  */
  if( pBt->inTrans==TRANS_WRITE || (pBt->inTrans==TRANS_READ && !wrflag) ){
    return SQLITE_OK;

    if( rc==SQLITE_OK ){
      pBt->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
      if( wrflag ) pBt->inStmt = 0;
    }else{
      unlockBtreeIfUnused(pBt);
    }
  }while( rc==SQLITE_BUSY && pBt->inTrans==TRANS_NONE &&
      (pH = pBt->pBusyHandler)!=0 && 
      pH->xFunc && pH->xFunc(pH->pArg, busy++)
  );
  return rc;
}

#ifndef SQLITE_OMIT_AUTOVACUUM

/*
** Set the pointer-map entries for all children of page pPage. Also, if

  }
  assert( totalSize+2*nCell<=pPage->nFree );
  assert( pPage->nCell==0 );
  cellptr = pPage->cellOffset;
  data = pPage->aData;
  hdr = pPage->hdrOffset;
  put2byte(&data[hdr+3], nCell);

  cellbody = allocateSpace(pPage, totalSize);
  assert( cellbody>0 );
  assert( pPage->nFree >= 2*nCell );
  pPage->nFree -= 2*nCell;
  for(i=0; i<nCell; i++){
    put2byte(&data[cellptr], cellbody);
    memcpy(&data[cellbody], apCell[i], aSize[i]);
    cellptr += 2;
    cellbody += aSize[i];
  }
  assert( cellbody==pPage->pBt->usableSize );

  pPage->nCell = nCell;
}

/*
** The following parameters determine how many adjacent pages get involved
** in a balancing operation.  NN is the number of neighbors on either side
** of the page that participate in the balancing operation.  NB is the

  assert( pParent );
  TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));

#ifndef SQLITE_OMIT_QUICKBALANCE
  /*
  ** A special case:  If a new entry has just been inserted into a
  ** table (that is, a btree with integer keys and all data at the leaves)
  ** an the new entry is the right-most entry in the tree (it has the
  ** largest key) then use the special balance_quick() routine for
  ** balancing.  balance_quick() is much faster and results in a tighter
  ** packing of data in the common case.
  */
  if( pPage->leaf &&
      pPage->intKey &&
      pPage->leafData &&

      cntNew[i-1]--;
      r = cntNew[i-1] - 1;
      d = r + 1 - leafData;
    }
    szNew[i] = szRight;
    szNew[i-1] = szLeft;
  }





  assert( cntNew[0]>0 );

  /*
  ** Allocate k new pages.  Reuse old pages where possible.
  */
  assert( pPage->pgno>1 );
  pageFlags = pPage->aData[0];
  for(i=0; i<k; i++){

  j = 0;
  for(i=0; i<nNew; i++){
    /* Assemble the new sibling page. */
    MemPage *pNew = apNew[i];
    assert( j<nMaxCells );
    assert( pNew->pgno==pgnoNew[i] );
    assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
    assert( pNew->nCell>0 );
    assert( pNew->nOverflow==0 );

#ifndef SQLITE_OMIT_AUTOVACUUM
    /* If this is an auto-vacuum database, update the pointer map entries
    ** that point to the siblings that were rearranged. These can be: left
    ** children of cells, the right-child of the page, or overflow pages
    ** pointed to by cells.

  int rc;
  BtCursor *pCur;
  if( pBt->inTrans!=TRANS_WRITE ){
    return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
  }
  for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
    if( pCur->pgnoRoot==(Pgno)iTable ){
      if( pCur->wrFlag==0 ) 
        return SQLITE_LOCKED;
      moveToRoot(pCur);
    }
  }
  rc = clearDatabasePage(pBt, (Pgno)iTable, 0, 0);
  if( rc ){
    sqlite3BtreeRollback(pBt);
  }

int sqlite3BtreeReset(Btree *pBt){
  if( pBt->pCursor ) return SQLITE_BUSY;
  pBt->inTrans = TRANS_NONE;
  unlockBtreeIfUnused(pBt);
  return sqlite3pager_reset(pBt->pPager);
}
#endif

}

**    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.6 2005/08/01 19:32:09 rmsimpson Exp $
*/
#ifndef _BTREE_H_
#define _BTREE_H_

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

#pragma unmanaged
extern "C"
{
  /*
** 2001 September 15
**
** 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.

**     CREATE INDEX
**     DROP INDEX
**     creating ID lists
**     BEGIN TRANSACTION
**     COMMIT
**     ROLLBACK
**
** $Id: build.c,v 1.6 2005/08/01 19:32:09 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.

    return 0;
  }

  p = sqlite3FindTable(pParse->db, zName, zDbase);
  if( p==0 ){
    if( zDbase ){
      sqlite3ErrorMsg(pParse, "no such table: %s.%s", zDbase, zName);
    }else if( sqlite3FindTable(pParse->db, zName, 0)!=0 ){
      sqlite3ErrorMsg(pParse, "table \"%s\" is not in database \"%s\"",
         zName, zDbase);
    }else{
      sqlite3ErrorMsg(pParse, "no such table: %s", zName);
    }
    pParse->checkSchema = 1;
  }
  return p;
}

*/
static void sqliteDeleteIndex(sqlite3 *db, Index *p){
  Index *pOld;

  assert( db!=0 && p->zName!=0 );
  pOld = (Index *)sqlite3HashInsert(&db->aDb[p->iDb].idxHash, p->zName,
                          strlen(p->zName)+1, 0);
  if( pOld!=0 && pOld!=p ){
    sqlite3HashInsert(&db->aDb[p->iDb].idxHash, pOld->zName,
                     strlen(pOld->zName)+1, pOld);
  }
  freeIndex(p);
}

/*
** For the index called zIdxName which is found in the database iDb,
** unlike that index from its Table then remove the index from
** the index hash table and free all memory structures associated

/*
** The token *pName contains the name of a database (either "main" or
** "temp" or the name of an attached db). This routine returns the
** index of the named database in db->aDb[], or -1 if the named db 
** does not exist.
*/
static int findDb(sqlite3 *db, Token *pName){
  int i = -1;    /* Database number */
  int n;         /* Number of characters in the name */
  Db *pDb;       /* A database whose name space is being searched */
  char *zName;   /* Name we are searching for */

  zName = sqlite3NameFromToken(pName);
  if( zName ){

){
  int iDb;                    /* Database holding the object */
  sqlite3 *db = pParse->db;

  if( pName2 && pName2->n>0 ){
    assert( !db->init.busy );
    *pUnqual = pName2;
    iDb = findDb(db, pName1);
    if( iDb<0 ){
      sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
      pParse->nErr++;
      return -1;
    }
  }else{
    assert( db->init.iDb==0 || db->init.busy );

  pParse->pNewTable = pTable;

  /* If this is the magic sqlite_sequence table used by autoincrement,
  ** then record a pointer to this table in the main database structure
  ** so that INSERT can find the table easily.
  */
#ifndef SQLITE_OMIT_AUTOINCREMENT
  if( strcmp(zName, "sqlite_sequence")==0 ){
    db->aDb[iDb].pSeqTab = pTable;
  }
#endif

  /* Begin generating the code that will insert the table record into
  ** the SQLITE_MASTER table.  Note in particular that we must go ahead
  ** and allocate the record number for the table entry now.  Before any

** 'CLOB'        | SQLITE_AFF_TEXT
** 'TEXT'        | SQLITE_AFF_TEXT
** 'BLOB'        | SQLITE_AFF_NONE
**
** If none of the substrings in the above table are found,
** SQLITE_AFF_NUMERIC is returned.
*/
static char sqlite3AffinityType(const char *zType, int nType){
  u32 h = 0;
  char aff = SQLITE_AFF_NUMERIC;
  const unsigned char *zIn = (const unsigned char *)zType;
  const unsigned char *zEnd = (zIn+nType);

  while( zIn!=zEnd ){
    h = (h<<8) + sqlite3UpperToLower[*zIn];
    zIn++;
    if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */
      aff = SQLITE_AFF_TEXT; 
    }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */

** parsing a CREATE TABLE statement.  The pFirst token is the first
** token in the sequence of tokens that describe the type of the
** column currently under construction.   pLast is the last token
** in the sequence.  Use this information to construct a string
** that contains the typename of the column and store that string
** in zType.
*/ 
void sqlite3AddColumnType(Parse *pParse, Token *pFirst, Token *pLast){
  Table *p;
  int i, j;
  int n;
  char *z;
  const unsigned char *zIn;

  Column *pCol;
  if( (p = pParse->pNewTable)==0 ) return;
  i = p->nCol-1;
  if( i<0 ) return;
  pCol = &p->aCol[i];
  zIn = pFirst->z;
  n = pLast->n + (pLast->z - zIn);
  assert( pCol->zType==0 );
  z = pCol->zType = (char *)sqliteMallocRaw(n+1);
  if( z==0 ) return;
  for(i=j=0; i<n; i++){
    int c = zIn[i];
    if( isspace(c) ) continue;
    z[j++] = c;
  }
  z[j] = 0;
  pCol->affinity = sqlite3AffinityType(z, n);
}

/*
** The expression is the default value for the most recently added column
** of the table currently under construction.
**
** Default value expressions must be constant.  Raise an exception if this
** is not the case.
**
** This routine is called by the parser while in the middle of
** parsing a CREATE TABLE statement.
*/
void sqlite3AddDefaultValue(Parse *pParse, Expr *pExpr){
  Table *p;
  Column *pCol;
  if( (p = pParse->pNewTable)==0 ) return;
  pCol = &(p->aCol[p->nCol-1]);
  if( !sqlite3ExprIsConstant(pExpr) ){
    sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
        pCol->zName);
  }else{
    sqlite3ExprDelete(pCol->pDflt);
    pCol->pDflt = sqlite3ExprDup(pExpr);

  }
  sqlite3ExprDelete(pExpr);
}

/*
** Designate the PRIMARY KEY for the table.  pList is a list of names 
** of columns that form the primary key.  If pList is NULL, then the

    /* Create the rootpage for the new table and push it onto the stack.
    ** A view has no rootpage, so just push a zero onto the stack for
    ** views.  Initialize zType at the same time.
    */
    if( p->pSelect==0 ){
      /* A regular table */
      /* sqlite3VdbeAddOp(v, OP_CreateTable, p->iDb, 0); */
      zType = "table";
      zType2 = "TABLE";
#ifndef SQLITE_OMIT_VIEW
    }else{
      /* A view */
    /*  sqlite3VdbeAddOp(v, OP_Integer, 0, 0); */
      zType = "view";
      zType2 = "VIEW";
#endif
    }

    /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
    ** statement to populate the new table. The root-page number for the

  **
  **     CREATE VIEW one AS SELECT * FROM two;
  **     CREATE VIEW two AS SELECT * FROM one;
  **
  ** Actually, this error is caught previously and so the following test
  ** should always fail.  But we will leave it in place just to be safe.
  */

  if( pTable->nCol<0 ){
    sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
    return 1;
  }



  /* If we get this far, it means we need to compute the table names.
  ** Note that the call to sqlite3ResultSetOfSelect() will expand any
  ** "*" elements in the results set of the view and will assign cursors
  ** to the elements of the FROM clause.  But we do not want these changes
  ** to be permanent.  So the computation is done on a copy of the SELECT
  ** statement that defines the view.

static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
  Table *pTab = pIndex->pTable;  /* The table that is indexed */
  int iTab = pParse->nTab;       /* Btree cursor used for pTab */
  int iIdx = pParse->nTab+1;     /* Btree cursor used for pIndex */
  int addr1;                     /* Address of top of loop */
  int tnum;                      /* Root page of index */
  Vdbe *v;                       /* Generate code into this virtual machine */
  int isUnique;                  /* True for a unique index */

#ifndef SQLITE_OMIT_AUTHORIZATION
  if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
      pParse->db->aDb[pIndex->iDb].zName ) ){
    return;
  }
#endif

  }else{
    tnum = pIndex->tnum;
    sqlite3VdbeAddOp(v, OP_Clear, tnum, pIndex->iDb);
  }
  sqlite3VdbeAddOp(v, OP_Integer, pIndex->iDb, 0);
  sqlite3VdbeOp3(v, OP_OpenWrite, iIdx, tnum,
                    (char*)&pIndex->keyInfo, P3_KEYINFO);
  sqlite3VdbeAddOp(v, OP_Integer, pTab->iDb, 0);
  sqlite3VdbeAddOp(v, OP_OpenRead, iTab, pTab->tnum);
  sqlite3VdbeAddOp(v, OP_SetNumColumns, iTab, pTab->nCol);
  addr1 = sqlite3VdbeAddOp(v, OP_Rewind, iTab, 0);
  sqlite3GenerateIndexKey(v, pIndex, iTab);
  isUnique = pIndex->onError!=OE_None;




  sqlite3VdbeAddOp(v, OP_IdxInsert, iIdx, isUnique);
  if( isUnique ){

    sqlite3VdbeChangeP3(v, -1, "indexed columns are not unique", P3_STATIC);

  }

  sqlite3VdbeAddOp(v, OP_Next, iTab, addr1+1);
  sqlite3VdbeChangeP2(v, addr1, sqlite3VdbeCurrentAddr(v));
  sqlite3VdbeAddOp(v, OP_Close, iTab, 0);
  sqlite3VdbeAddOp(v, OP_Close, iIdx, 0);
}

/*

      iDb = 1;
    }
#endif

    if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
        sqlite3FixSrcList(&sFix, pTblName)
    ){
      goto exit_create_index;


    }
    pTab = sqlite3LocateTable(pParse, pTblName->a[0].zName, 
        pTblName->a[0].zDatabase);
    if( !pTab ) goto exit_create_index;
    assert( iDb==pTab->iDb );
  }else{
    assert( pName==0 );

#endif

  /* If pList==0, it means this routine was called to make a primary
  ** key out of the last column added to the table under construction.
  ** So create a fake list to simulate this.
  */
  if( pList==0 ){
    nullId.z = (const unsigned char *)pTab->aCol[pTab->nCol-1].zName;
    nullId.n = strlen((const char *)nullId.z);
    pList = sqlite3ExprListAppend(0, 0, &nullId);
    if( pList==0 ) goto exit_create_index;
  }

  /* 
  ** Allocate the index structure. 
  */
  pIndex = (Index *)sqliteMalloc( sizeof(Index) + strlen(zName) + 1 +
                        (sizeof(int) + sizeof(CollSeq*))*pList->nExpr );
  if( sqlite3_malloc_failed ) goto exit_create_index;
  pIndex->aiColumn = (int*)&pIndex->keyInfo.aColl[pList->nExpr];

  pIndex->zName = (char*)&pIndex->aiColumn[pList->nExpr];
  strcpy(pIndex->zName, zName);
  pIndex->pTable = pTab;
  pIndex->nColumn = pList->nExpr;
  pIndex->onError = onError;
  pIndex->autoIndex = pName==0;
  pIndex->iDb = iDb;

    if( !db->init.busy && 
        sqlite3CheckCollSeq(pParse, pIndex->keyInfo.aColl[i]) 
    ){
      goto exit_create_index;
    }
  }
  pIndex->keyInfo.nField = pList->nExpr;


  if( pTab==pParse->pNewTable ){
    /* This routine has been called to create an automatic index as a
    ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
    ** a PRIMARY KEY or UNIQUE clause following the column definitions.
    ** i.e. one of:
    **

    freeIndex(pIndex);
  }
  sqlite3ExprListDelete(pList);
  sqlite3SrcListDelete(pTblName);
  sqliteFree(zName);
  return;
}
































/*
** This routine will drop an existing named index.  This routine
** implements the DROP INDEX statement.
*/
void sqlite3DropIndex(Parse *pParse, SrcList *pName){
  Index *pIndex;

IdList *sqlite3IdListAppend(IdList *pList, Token *pToken){
  if( pList==0 ){
    pList = (IdList *)sqliteMalloc( sizeof(IdList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 0;
  }
  if( pList->nId>=pList->nAlloc ){
	  struct IdList::IdList_item *a;
    pList->nAlloc = pList->nAlloc*2 + 5;
	a = (IdList::IdList_item *)sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0]) );
    if( a==0 ){
      sqlite3IdListDelete(pList);
      return 0;
    }
    pList->a = a;
  }
  memset(&pList->a[pList->nId], 0, sizeof(pList->a[0]));
  pList->a[pList->nId].zName = sqlite3NameFromToken(pToken);
  pList->nId++;
  return pList;
}



























/*
** Append a new table name to the given SrcList.  Create a new SrcList if
** need be.  A new entry is created in the SrcList even if pToken is NULL.
**
** A new SrcList is returned, or NULL if malloc() fails.
**

** like this:
**
**         sqlite3SrcListAppend(A,B,C);
**
** Then C is the table name and B is the database name.
*/
SrcList *sqlite3SrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){
	struct SrcList::SrcList_item *pItem;
  if( pList==0 ){
    pList = (SrcList *)sqliteMalloc( sizeof(SrcList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 1;
  }
  if( pList->nSrc>=pList->nAlloc ){
    SrcList *pNew;
    pList->nAlloc *= 2;
    pNew = (SrcList *)sqliteRealloc(pList,
               sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) );
    if( pNew==0 ){
      sqlite3SrcListDelete(pList);
      return 0;
    }
    pList = pNew;
  }
  pItem = &pList->a[pList->nSrc];
  memset(pItem, 0, sizeof(pList->a[0]));
  if( pDatabase && pDatabase->z==0 ){
    pDatabase = 0;
  }
  if( pDatabase && pTable ){
    Token *pTemp = pDatabase;
    pDatabase = pTable;

*/
void sqlite3SrcListAddAlias(SrcList *pList, Token *pToken){
  if( pList && pList->nSrc>0 ){
    pList->a[pList->nSrc-1].zAlias = sqlite3NameFromToken(pToken);
  }
}

/*
** Delete an IdList.
*/
void sqlite3IdListDelete(IdList *pList){
  int i;
  if( pList==0 ) return;
  for(i=0; i<pList->nId; i++){
    sqliteFree(pList->a[i].zName);
  }
  sqliteFree(pList->a);
  sqliteFree(pList);
}

/*
** Return the index in pList of the identifier named zId.  Return -1
** if not found.
*/
int sqlite3IdListIndex(IdList *pList, const char *zName){
  int i;
  if( pList==0 ) return -1;
  for(i=0; i<pList->nId; i++){
    if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
  }
  return -1;
}

/*
** Delete an entire SrcList including all its substructure.
*/
void sqlite3SrcListDelete(SrcList *pList){
  int i;
  struct SrcList::SrcList_item *pItem;
  if( pList==0 ) return;

#endif

/*
** Recompute all indices of pTab that use the collating sequence pColl.
** If pColl==0 then recompute all indices of pTab.
*/
#ifndef SQLITE_OMIT_REINDEX
void reindexTable(Parse *pParse, Table *pTab, CollSeq *pColl){
  Index *pIndex;              /* An index associated with pTab */

  for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
    if( pColl==0 || collationMatch(pColl,pIndex) ){
      sqlite3BeginWriteOperation(pParse, 0, pTab->iDb);
      sqlite3RefillIndex(pParse, pIndex, -1);
    }
  }
}
#endif

/*
** Recompute all indices of all tables in all databases where the
** indices use the collating sequence pColl.  If pColl==0 then recompute
** all indices everywhere.
*/
#ifndef SQLITE_OMIT_REINDEX
void reindexDatabases(Parse *pParse, CollSeq *pColl){
  Db *pDb;                    /* A single database */
  int iDb;                    /* The database index number */
  sqlite3 *db = pParse->db;   /* The database connection */
  HashElem *k;                /* For looping over tables in pDb */
  Table *pTab;                /* A table in the database */

  for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
    if( pDb==0 ) continue;
      for(k=sqliteHashFirst(&pDb->tblHash);  k; k=sqliteHashNext(k)){
      pTab = (Table*)sqliteHashData(k);
      reindexTable(pParse, pTab, pColl);
    }
  }
}
#endif

    sqlite3BeginWriteOperation(pParse, 0, iDb);
    sqlite3RefillIndex(pParse, pIndex, -1);
    return;
  }
  sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
}
#endif

}

#pragma unmanaged
extern "C"
{
  /*
** 2005 May 23 
**
** 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 functions used to access the internal hash tables
** of user defined functions and collation sequences.
**
** $Id: callback.c,v 1.2 2005/08/01 19:32:09 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.

** array of three CollSeq structures. The first is the collation sequence
** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be.
**
** Stored immediately after the three collation sequences is a copy of
** the collation sequence name. A pointer to this string is stored in
** each collation sequence structure.
*/
static CollSeq * findCollSeqEntry(
  sqlite3 *db,
  const char *zName,
  int nName,
  int create
){
  CollSeq *pColl;
  if( nName<0 ) nName = strlen(zName);

  }

  /* If the createFlag parameter is true, and the seach did not reveal an
  ** exact match for the name, number of arguments and encoding, then add a
  ** new entry to the hash table and return it.
  */
  if( createFlag && bestmatch<6 && 
      (pBest = (FuncDef *)sqliteMalloc(sizeof(*pBest)+nName+1)) ){
    pBest->nArg = nArg;
    pBest->pNext = pFirst;
    pBest->zName = (char*)&pBest[1];
    pBest->iPrefEnc = enc;
    memcpy(pBest->zName, zName, nName);
    pBest->zName[nName] = 0;
    if( pBest==sqlite3HashInsert(&db->aFunc,pBest->zName,nName,(void*)pBest) ){
      sqliteFree(pBest);
      return 0;
    }
  }

  if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
    return pBest;
  }
  return 0;
}

}

** 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.6 2005/08/01 19:32:09 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.

  return cnt;
}

/*
** Read text from z[] and convert into a floating point number.  Return
** the number of digits converted.
*/
static int getValue(const char *z, double *pR){
  const char *zEnd;
  *pR = sqlite3AtoF(z, &zEnd);
  return zEnd - z;
}

/*
** Parse a timezone extension on the end of a date-time.
** The extension is of the form:
**
**        (+/-)HH:MM
**

  }else if( sqlite3StrICmp(zDate,"now")==0){
    double r;
    sqlite3OsCurrentTime(&r);
    p->rJD = r;
    p->validJD = 1;
    return 0;
  }else if( sqlite3IsNumber(zDate, 0, SQLITE_UTF8) ){
    p->rJD = sqlite3AtoF(zDate, 0);
    p->validJD = 1;
    return 0;
  }
  return 1;
}

/*

  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
    sqlite3_create_function(db, aFuncs[i].zName, 0, SQLITE_UTF8, 
        aFuncs[i].zFormat, currentTimeFunc, 0, 0);
  }
#endif
}

}

**    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.6 2005/08/01 19:32:09 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.

*/
void sqlite3OpenTableForReading(
  Vdbe *v,        /* Generate code into this VDBE */
  int iCur,       /* The cursor number of the table */
  Table *pTab     /* The table to be opened */
){
  sqlite3VdbeAddOp(v, OP_Integer, pTab->iDb, 0);
  sqlite3VdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum);
  VdbeComment((v, "# %s", pTab->zName));

  sqlite3VdbeAddOp(v, OP_SetNumColumns, iCur, pTab->nCol);
}


/*
** Generate code for a DELETE FROM statement.
**

    */
    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0);
    if( pWInfo==0 ) goto delete_from_cleanup;

    /* Remember the rowid of every item to be deleted.
    */
    sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0);
    sqlite3VdbeAddOp(v, OP_ListWrite, 0, 0);
    if( db->flags & SQLITE_CountRows ){
      sqlite3VdbeAddOp(v, OP_AddImm, 1, 0);
    }

    /* End the database scan loop.
    */
    sqlite3WhereEnd(pWInfo);

    /* Open the pseudo-table used to store OLD if there are triggers.
    */
    if( triggers_exist ){
      sqlite3VdbeAddOp(v, OP_OpenPseudo, oldIdx, 0);
      sqlite3VdbeAddOp(v, OP_SetNumColumns, oldIdx, pTab->nCol);
    }

    /* Delete every item whose key was written to the list during the
    ** database scan.  We have to delete items after the scan is complete
    ** because deleting an item can change the scan order.
    */
    sqlite3VdbeAddOp(v, OP_ListRewind, 0, 0);
    end = sqlite3VdbeMakeLabel(v);

    /* This is the beginning of the delete loop when there are
    ** row triggers.
    */
    if( triggers_exist ){
      addr = sqlite3VdbeAddOp(v, OP_ListRead, 0, end);
      if( !isView ){
        sqlite3VdbeAddOp(v, OP_Dup, 0, 0);
        sqlite3OpenTableForReading(v, iCur, pTab);
      }
      sqlite3VdbeAddOp(v, OP_MoveGe, iCur, 0);
      sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0);
      sqlite3VdbeAddOp(v, OP_RowData, iCur, 0);
      sqlite3VdbeAddOp(v, OP_Insert, oldIdx, 0);
      if( !isView ){
        sqlite3VdbeAddOp(v, OP_Close, iCur, 0);
      }

      (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_BEFORE, pTab,
          -1, oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default,
          addr);
    }

    if( !isView ){
      /* Open cursors for the table we are deleting from and all its
      ** indices.  If there are row triggers, this happens inside the
      ** OP_ListRead loop because the cursor have to all be closed
      ** before the trigger fires.  If there are no row triggers, the
      ** cursors are opened only once on the outside the loop.
      */
      sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);

      /* This is the beginning of the delete loop when there are no
      ** row triggers */
      if( !triggers_exist ){ 
        addr = sqlite3VdbeAddOp(v, OP_ListRead, 0, end);
      }

      /* Delete the row */
      sqlite3GenerateRowDelete(db, v, pTab, iCur, pParse->nested==0);
    }

    /* If there are row triggers, close all cursors then invoke

          oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default,
          addr);
    }

    /* End of the delete loop */
    sqlite3VdbeAddOp(v, OP_Goto, 0, addr);
    sqlite3VdbeResolveLabel(v, end);
    sqlite3VdbeAddOp(v, OP_ListReset, 0, 0);

    /* Close the cursors after the loop if there are no row triggers */
    if( !triggers_exist ){
      for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
        sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum);
      }
      sqlite3VdbeAddOp(v, OP_Close, iCur, 0);

    if( idx==pTab->iPKey ){
      sqlite3VdbeAddOp(v, OP_Dup, j, 0);
    }else{
      sqlite3VdbeAddOp(v, OP_Column, iCur, idx);
      sqlite3ColumnDefault(v, pTab, idx);
    }
  }
  sqlite3VdbeAddOp(v, OP_MakeRecord, pIdx->nColumn, (1<<24));
  sqlite3IndexAffinityStr(v, pIdx);
}

}

**    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.6 2005/08/01 19:32:10 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

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

**
** CREATE TABLE t1(a);
** SELECT * FROM t1 WHERE a;
** SELECT a AS b FROM t1 WHERE b;
** SELECT * FROM t1 WHERE (select a from t1);
*/
char sqlite3ExprAffinity(Expr *pExpr){

  if( pExpr->op==TK_AS ){
    return sqlite3ExprAffinity(pExpr->pLeft);
  }
  if( pExpr->op==TK_SELECT ){
    return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr);
  }





  return pExpr->affinity;
}

/*
** Return the default collation sequence for the expression pExpr. If
** there is no default collation type, return 0.
*/
CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
  CollSeq *pColl = 0;
  if( pExpr ){
    pColl = pExpr->pColl;
    if( pExpr->op==TK_AS && !pColl ){
      return sqlite3ExprCollSeq(pParse, pExpr->pLeft);
    }
  }
  if( sqlite3CheckCollSeq(pParse, pColl) ){ 
    pColl = 0;
  }
  return pColl;

    /* Neither side of the comparison is a column.  Compare the
    ** results directly.
    */
    /* return SQLITE_AFF_NUMERIC;  // Ticket #805 */
    return SQLITE_AFF_NONE;
  }else{
    /* One side is a column, the other is not. Use the columns affinity. */

    return (aff1 + aff2);
  }
}

/*
** pExpr is a comparison operator.  Return the type affinity that should
** be applied to both operands prior to doing the comparison.

  }
  return pNew;
}

/*
** When doing a nested parse, you can include terms in an expression
** that look like this:   #0 #1 #2 ...  These terms refer to elements
** on the stack.  "#0" (or just "#") means the top of the stack.
** "#1" means the next down on the stack.  And so forth.  #-1 means
** memory location 0.  #-2 means memory location 1.  And so forth.
**
** This routine is called by the parser to deal with on of those terms.
** It immediately generates code to store the value in a memory location.
** The returns an expression that will code to extract the value from
** that memory location as needed.
*/
Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){
  Vdbe *v = pParse->pVdbe;
  Expr *p;
  int depth;
  if( v==0 ) return 0;
  if( pParse->nested==0 ){
    sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", pToken);
    return 0;
  }

  p = sqlite3Expr(TK_REGISTER, 0, 0, pToken);
  if( p==0 ){
    return 0;  /* Malloc failed */
  }
  depth = atoi((char *)&pToken->z[1]);
  if( depth>=0 ){
    p->iTable = pParse->nMem++;
    sqlite3VdbeAddOp(v, OP_Dup, depth, 0);
    sqlite3VdbeAddOp(v, OP_MemStore, p->iTable, 1);
  }else{
    p->iTable = -1-depth;
  }
  return p;
}

/*
** Join two expressions using an AND operator.  If either expression is
** NULL, then just return the other expression.
*/

  if( pToken->n==1 ){
    /* Wildcard of the form "?".  Assign the next variable number */
    pExpr->iTable = ++pParse->nVar;
  }else if( pToken->z[0]=='?' ){
    /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
    ** use it as the variable number */
    int i;
    pExpr->iTable = i = atoi((char *)&pToken->z[1]);
    if( i<1 || i>SQLITE_MAX_VARIABLE_NUMBER ){
      sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
          SQLITE_MAX_VARIABLE_NUMBER);
    }
    if( i>pParse->nVar ){
      pParse->nVar = i;
    }

  sqlite3ExprDelete(p->pLeft);
  sqlite3ExprDelete(p->pRight);
  sqlite3ExprListDelete(p->pList);
  sqlite3SelectDelete(p->pSelect);
  sqliteFree(p);
}

















/*
** The following group of routines make deep copies of expressions,
** expression lists, ID lists, and select statements.  The copies can
** be deleted (by being passed to their respective ...Delete() routines)
** without effecting the originals.
**
** The expression list, ID, and source lists return by sqlite3ExprListDup(),
** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded 
** by subsequent calls to sqlite*ListAppend() routines.
**
** Any tables that the SrcList might point to are not duplicated.
*/
Expr *sqlite3ExprDup(Expr *p){
  Expr *pNew;
  if( p==0 ) return 0;
  pNew = (Expr *)sqliteMallocRaw( sizeof(*p) );
  if( pNew==0 ) return 0;
  memcpy(pNew, p, sizeof(*pNew));
  if( p->token.z!=0 ){
    pNew->token.z = (const unsigned char *)sqliteStrNDup((char *)p->token.z, p->token.n);
    pNew->token.dyn = 1;
  }else{
    assert( pNew->token.z==0 );
  }
  pNew->span.z = 0;
  pNew->pLeft = sqlite3ExprDup(p->pLeft);
  pNew->pRight = sqlite3ExprDup(p->pRight);
  pNew->pList = sqlite3ExprListDup(p->pList);
  pNew->pSelect = sqlite3SelectDup(p->pSelect);
  pNew->pTab = p->pTab;
  return pNew;
}
void sqlite3TokenCopy(Token *pTo, Token *pFrom){
  if( pTo->dyn ) sqliteFree((char*)pTo->z);
  if( pFrom->z ){
    pTo->n = pFrom->n;
    pTo->z = (const unsigned char *)sqliteStrNDup((char *)pFrom->z, pFrom->n);
    pTo->dyn = 1;
  }else{
    pTo->z = 0;
  }
}
ExprList *sqlite3ExprListDup(ExprList *p){
  ExprList *pNew;

  int nByte;
  if( p==0 ) return 0;
  nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
  pNew = (SrcList *)sqliteMallocRaw( nByte );
  if( pNew==0 ) return 0;
  pNew->nSrc = pNew->nAlloc = p->nSrc;
  for(i=0; i<p->nSrc; i++){
	  struct SrcList::SrcList_item *pNewItem = &pNew->a[i];
	  struct SrcList::SrcList_item *pOldItem = &p->a[i];
    Table *pTab;
    pNewItem->zDatabase = sqliteStrDup(pOldItem->zDatabase);
    pNewItem->zName = sqliteStrDup(pOldItem->zName);
    pNewItem->zAlias = sqliteStrDup(pOldItem->zAlias);
    pNewItem->jointype = pOldItem->jointype;
    pNewItem->iCursor = pOldItem->iCursor;
    pTab = pNewItem->pTab = pOldItem->pTab;

  pNew->nId = pNew->nAlloc = p->nId;
  pNew->a = (IdList::IdList_item *)sqliteMallocRaw( p->nId*sizeof(p->a[0]) );
  if( pNew->a==0 ){
    sqliteFree(pNew);
    return 0;
  }
  for(i=0; i<p->nId; i++){
	  struct IdList::IdList_item *pNewItem = &pNew->a[i];
	  struct IdList::IdList_item *pOldItem = &p->a[i];
    pNewItem->zName = sqliteStrDup(pOldItem->zName);
    pNewItem->idx = pOldItem->idx;
  }
  return pNew;
}
Select *sqlite3SelectDup(Select *p){
  Select *pNew;

  pNew->pOrderBy = sqlite3ExprListDup(p->pOrderBy);
  pNew->op = p->op;
  pNew->pPrior = sqlite3SelectDup(p->pPrior);
  pNew->pLimit = sqlite3ExprDup(p->pLimit);
  pNew->pOffset = sqlite3ExprDup(p->pOffset);
  pNew->iLimit = -1;
  pNew->iOffset = -1;
  pNew->ppOpenTemp = 0;
  pNew->isResolved = p->isResolved;
  pNew->isAgg = p->isAgg;
  return pNew;
}
#else
Select *sqlite3SelectDup(Select *p){
  assert( p==0 );

    pList = (ExprList *)sqliteMalloc( sizeof(ExprList) );
    if( pList==0 ){
      goto no_mem;
    }
    assert( pList->nAlloc==0 );
  }
  if( pList->nAlloc<=pList->nExpr ){
	  struct ExprList::ExprList_item *a;
    int n = pList->nAlloc*2 + 4;
	a = (ExprList::ExprList_item *)sqliteRealloc(pList->a, n*sizeof(pList->a[0]));
    if( a==0 ){
      goto no_mem;
    }
    pList->a = a;
    pList->nAlloc = n;
  }
  assert( pList->a!=0 );
  if( pExpr || pName ){
	  struct ExprList::ExprList_item *pItem = &pList->a[pList->nExpr++];
    memset(pItem, 0, sizeof(*pItem));
    pItem->zName = sqlite3NameFromToken(pName);
    pItem->pExpr = pExpr;
  }
  return pList;

no_mem:     

**
** After walking the whole tree, if no nodes are found that disqualify
** the expression as constant, then we assume the whole expression
** is constant.  See sqlite3ExprIsConstant() for additional information.
*/
static int exprNodeIsConstant(void *pArg, Expr *pExpr){
  switch( pExpr->op ){





    case TK_ID:
    case TK_COLUMN:
    case TK_DOT:
    case TK_AGG_FUNCTION:
    case TK_FUNCTION:
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_SELECT:
    case TK_EXISTS:
#endif
      *((int*)pArg) = 0;
      return 2;
    default:
      return 0;
  }
}

/*
** Walk an expression tree.  Return 1 if the expression is constant
** and 0 if it involves variables.
**
** For the purposes of this function, a double-quoted string (ex: "abc")
** is considered a variable but a single-quoted string (ex: 'abc') is
** a constant.
*/
int sqlite3ExprIsConstant(Expr *p){
  int isConst = 1;
  walkExprTree(p, exprNodeIsConstant, &isConst);
  return isConst;
}
















/*
** If the expression p codes a constant integer that is small enough
** to fit in a 32-bit integer, return 1 and put the value of the integer
** in *pValue.  If the expression is not an integer or if it is too big
** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
*/
int sqlite3ExprIsInteger(Expr *p, int *pValue){
  switch( p->op ){
    case TK_INTEGER: {
      if( sqlite3GetInt32((char *)p->token.z, pValue) ){
        return 1;
      }
      break;
    }
    case TK_UPLUS: {
      return sqlite3ExprIsInteger(p->pLeft, pValue);
    }

**
** The first form is handled by creating a set holding the list
** of allowed values.  The second form causes the SELECT to generate 
** a temporary table.
*/
#ifndef SQLITE_OMIT_SUBQUERY
void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
  int label = 0;                         /* Address after sub-select code */
  Vdbe *v = sqlite3GetVdbe(pParse);
  if( v==0 ) return;




  /* If this is not a variable (correlated) select, then execute

  ** it only once. Unless this is part of a trigger program. In
  ** that case re-execute every time (this could be optimized).



  */
  if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){
    int mem = pParse->nMem++;
    sqlite3VdbeAddOp(v, OP_MemLoad, mem, 0);
    label = sqlite3VdbeMakeLabel(v);
    sqlite3VdbeAddOp(v, OP_If, 0, label);

    sqlite3VdbeAddOp(v, OP_Integer, 1, 0);
    sqlite3VdbeAddOp(v, OP_MemStore, mem, 1);
  }

  if( pExpr->pSelect ){
    sqlite3VdbeAddOp(v, OP_AggContextPush, 0, 0);
  }

  switch( pExpr->op ){
    case TK_IN: {
      char affinity;
      KeyInfo keyInfo;
      int addr;        /* Address of OP_OpenTemp instruction */

      affinity = sqlite3ExprAffinity(pExpr->pLeft);

      /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
      ** expression it is handled the same way. A temporary table is 
      ** filled with single-field index keys representing the results
      ** from the SELECT or the <exprlist>.
      **
      ** If the 'x' expression is a column value, or the SELECT...
      ** statement returns a column value, then the affinity of that
      ** column is used to build the index keys. If both 'x' and the
      ** SELECT... statement are columns, then numeric affinity is used
      ** if either column has NUMERIC or INTEGER affinity. If neither
      ** 'x' nor the SELECT... statement are columns, then numeric affinity
      ** is used.
      */
      pExpr->iTable = pParse->nTab++;
      addr = sqlite3VdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 0);
      memset(&keyInfo, 0, sizeof(keyInfo));
      keyInfo.nField = 1;
      sqlite3VdbeAddOp(v, OP_SetNumColumns, pExpr->iTable, 1);

      if( pExpr->pSelect ){
        /* Case 1:     expr IN (SELECT ...)
        **

        **
	** For each expression, build an index key from the evaluation and
        ** store it in the temporary table. If <expr> is a column, then use
        ** that columns affinity when building index keys. If <expr> is not
        ** a column, use numeric affinity.
        */
        int i;



        if( !affinity ){
          affinity = SQLITE_AFF_NUMERIC;
        }
        keyInfo.aColl[0] = pExpr->pLeft->pColl;

        /* Loop through each expression in <exprlist>. */
        for(i=0; i<pExpr->pList->nExpr; i++){
          Expr *pE2 = pExpr->pList->a[i].pExpr;

          /* Check that the expression is constant and valid. */




          if( !sqlite3ExprIsConstant(pE2) ){
            sqlite3ErrorMsg(pParse,
              "right-hand side of IN operator must be constant");
            return;




          }

          /* Evaluate the expression and insert it into the temp table */
          sqlite3ExprCode(pParse, pE2);
          sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1);
          sqlite3VdbeAddOp(v, OP_IdxInsert, pExpr->iTable, 0);
        }
      }
      sqlite3VdbeChangeP3(v, addr, (char *)(void *)&keyInfo, P3_KEYINFO);
      break;
    }

    case TK_EXISTS:
    case TK_SELECT: {
      /* This has to be a scalar SELECT.  Generate code to put the
      ** value of this select in a memory cell and record the number
      ** of the memory cell in iColumn.
      */
      int sop;
      Select *pSel;

      pExpr->iColumn = pParse->nMem++;
      pSel = pExpr->pSelect;
      if( pExpr->op==TK_SELECT ){
        sop = SRT_Mem;
      }else{
        static const Token one = { (const unsigned char *)"1", 0, 1 };
        sop = SRT_Exists;
        sqlite3ExprListDelete(pSel->pEList);
        pSel->pEList = sqlite3ExprListAppend(0, 
                          sqlite3Expr(TK_INTEGER, 0, 0, &one), 0);
      }
      sqlite3Select(pParse, pSel, sop, pExpr->iColumn, 0, 0, 0, 0);
      break;
    }
  }

  if( pExpr->pSelect ){
    sqlite3VdbeAddOp(v, OP_AggContextPop, 0, 0);
  }
  if( label<0 ){
    sqlite3VdbeResolveLabel(v, label);
  }
  return;
}
#endif /* SQLITE_OMIT_SUBQUERY */

/*
** Generate an instruction that will put the integer describe by
** text z[0..n-1] on the stack.
*/
static void codeInteger(Vdbe *v, const char *z, int n){
  int i;
  if( sqlite3GetInt32(z, &i) ){
    sqlite3VdbeAddOp(v, OP_Integer, i, 0);
  }else if( sqlite3FitsIn64Bits(z) ){
    sqlite3VdbeOp3(v, OP_Integer, 0, 0, z, n);
  }else{
    sqlite3VdbeOp3(v, OP_Real, 0, 0, z, n);
  }
}

/*
** Generate code into the current Vdbe to evaluate the given

        sqlite3ColumnDefault(v, pExpr->pTab, pExpr->iColumn);
      }else{
        sqlite3VdbeAddOp(v, OP_Rowid, pExpr->iTable, 0);
      }
      break;
    }
    case TK_INTEGER: {
      codeInteger(v, (char *)pExpr->token.z, pExpr->token.n);
      break;
    }
    case TK_FLOAT:
    case TK_STRING: {
      assert( TK_FLOAT==OP_Real );
      assert( TK_STRING==OP_String8 );

      sqlite3VdbeOp3(v, op, 0, 0, (char *)pExpr->token.z, pExpr->token.n);
      sqlite3VdbeDequoteP3(v, -1);
      break;
    }
    case TK_NULL: {
      sqlite3VdbeAddOp(v, OP_Null, 0, 0);
      break;
    }
#ifndef SQLITE_OMIT_BLOB_LITERAL
    case TK_BLOB: {
      assert( TK_BLOB==OP_HexBlob );
      sqlite3VdbeOp3(v, op, 0, 0, (char *)pExpr->token.z+1, pExpr->token.n-1);
      sqlite3VdbeDequoteP3(v, -1);
      break;
    }
#endif
    case TK_VARIABLE: {
      sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0);
      if( pExpr->token.n>1 ){
        sqlite3VdbeChangeP3(v, -1, (char *)pExpr->token.z, pExpr->token.n);
      }
      break;
    }
    case TK_REGISTER: {
      sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iTable, 0);
      break;
    }
















    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE:
    case TK_NE:
    case TK_EQ: {
      assert( TK_LT==OP_Lt );

                       "RAISE() may only be used within a trigger-program");
	return;
      }
      if( pExpr->iColumn!=OE_Ignore ){
         assert( pExpr->iColumn==OE_Rollback ||
                 pExpr->iColumn == OE_Abort ||
                 pExpr->iColumn == OE_Fail );

         sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn,
                        (char *)pExpr->token.z, pExpr->token.n);
         sqlite3VdbeDequoteP3(v, -1);
      } else {
         assert( pExpr->iColumn == OE_Ignore );
         sqlite3VdbeAddOp(v, OP_ContextPop, 0, 0);
         sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
         VdbeComment((v, "# raise(IGNORE)"));
      }
    }

*/
int sqlite3ExprCodeExprList(
  Parse *pParse,     /* Parsing context */
  ExprList *pList    /* The expression list to be coded */
){
  struct ExprList::ExprList_item *pItem;
  int i, n;
  Vdbe *v;
  if( pList==0 ) return 0;
  v = sqlite3GetVdbe(pParse);
  n = pList->nExpr;
  for(pItem=pList->a, i=0; i<n; i++, pItem++){
    sqlite3ExprCode(pParse, pItem->pExpr);
  }
  return n;
}

/*
** Generate code for a boolean expression such that a jump is made

    return 0;
  }
  if( pA->pSelect || pB->pSelect ) return 0;
  if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
  if( pA->token.z ){
    if( pB->token.z==0 ) return 0;
    if( pB->token.n!=pA->token.n ) return 0;
    if( sqlite3StrNICmp((char *)pA->token.z, (char *)pB->token.z, pB->token.n)!=0 ) return 0;
  }
  return 1;
}

/*
** Add a new element to the pParse->aAgg[] array and return its index.
** The new element is initialized to zero.  The calling function is

        if( i>=pParse->nAgg ){
          u8 enc = pParse->db->enc;
          i = appendAggInfo(pParse);
          if( i<0 ) return 1;
          pParse->aAgg[i].isAgg = 1;
          pParse->aAgg[i].pExpr = pExpr;
          pParse->aAgg[i].pFunc = sqlite3FindFunction(pParse->db,
               (char *)pExpr->token.z, pExpr->token.n,
               pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
        }
        pExpr->iAgg = i;
        return 1;
      }
    }
  }

** the number of errors.
*/
int sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
  int nErr = pNC->pParse->nErr;
  walkExprTree(pExpr, analyzeAggregate, pNC);
  return pNC->pParse->nErr - nErr;
}

}

** 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.6 2005/08/01 19:32:10 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
#include "vdbeInt.h"
#include "os.h"




static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
  return context->pColl;
}

/*
** Implementation of the non-aggregate min() and max() functions
*/

    case SQLITE_INTEGER: z = "integer"; break;
    case SQLITE_TEXT:    z = "text";    break;
    case SQLITE_FLOAT:   z = "real";    break;
    case SQLITE_BLOB:    z = "blob";    break;
  }
  sqlite3_result_text(context, z, -1, SQLITE_STATIC);
}


/*
** Implementation of the length() function
*/
static void lengthFunc(
  sqlite3_context *context,
  int argc,

/*
** Implementation of the round() function
*/
static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  int n = 0;
  double r;
  char zBuf[100];
  assert( argc==1 || argc==2 );
  if( argc==2 ){
    if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
    n = sqlite3_value_int(argv[1]);
    if( n>30 ) n = 30;
    if( n<0 ) n = 0;
  }
  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
  r = sqlite3_value_double(argv[0]);
  sprintf(zBuf,"%.*f",n,r);
  sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
}

/*
** Implementation of the upper() and lower() SQL functions.
*/
static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  unsigned char *z;
  int i;
  if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
  z = (unsigned char *)sqliteMalloc(sqlite3_value_bytes(argv[0])+1);
  if( z==0 ) return;
  strcpy((char *)z, (char *)sqlite3_value_text(argv[0]));
  for(i=0; z[i]; i++){
    z[i] = toupper(z[i]);
  }
  sqlite3_result_text(context, (char *)z, -1, SQLITE_TRANSIENT);
  sqliteFree(z);
}
static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  unsigned char *z;
  int i;
  if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
  z = (unsigned char *)sqliteMalloc(sqlite3_value_bytes(argv[0])+1);
  if( z==0 ) return;
  strcpy((char *)z, (char *)sqlite3_value_text(argv[0]));
  for(i=0; z[i]; i++){
    z[i] = tolower(z[i]);
  }
  sqlite3_result_text(context, (char *)z, -1, SQLITE_TRANSIENT);
  sqliteFree(z);
}

/*
** Implementation of the IFNULL(), NVL(), and COALESCE() functions.  
** All three do the same thing.  They return the first non-NULL
** argument.

*/
struct compareInfo {
  u8 matchAll;
  u8 matchOne;
  u8 matchSet;
  u8 noCase;
};

static const struct compareInfo globInfo = { '*', '?', '[', 0 };





static const struct compareInfo likeInfo = { '%', '_',   0, 1 };

/*
** X is a pointer to the first byte of a UTF-8 character.  Increment
** X so that it points to the next character.  This only works right
** if X points to a well-formed UTF-8 string.
*/
#define sqliteNextChar(X)  while( (0xc0&*++(X))==0x80 ){}

      zString++;
      prevEscape = 0;
    }
  }
  return *zString==0;
}











/*
** Implementation of the like() SQL function.  This function implements
** the build-in LIKE operator.  The first argument to the function is the
** pattern and the second argument is the string.  So, the SQL statements:
**
**       A LIKE B
**
** is implemented as like(B,A).
**
** If the pointer retrieved by via a call to sqlite3_user_data() is
** not NULL, then this function uses UTF-16. Otherwise UTF-8.
*/
static void likeFunc(
  sqlite3_context *context, 
  int argc, 
  sqlite3_value **argv
){
  const unsigned char *zA = sqlite3_value_text(argv[0]);
  const unsigned char *zB = sqlite3_value_text(argv[1]);
  int escape = 0;
  if( argc==3 ){
    /* The escape character string must consist of a single UTF-8 character.
    ** Otherwise, return an error.
    */
    const unsigned char *zEsc = sqlite3_value_text(argv[2]);
    if( sqlite3utf8CharLen((char *)zEsc, -1)!=1 ){
      sqlite3_result_error(context, 
          "ESCAPE expression must be a single character", -1);
      return;
    }
    escape = sqlite3ReadUtf8(zEsc);
  }
  if( zA && zB ){
    sqlite3_result_int(context, patternCompare(zA, zB, &likeInfo, escape));
  }
}

/*
** Implementation of the glob() SQL function.  This function implements
** the build-in GLOB operator.  The first argument to the function is the
** string and the second argument is the pattern.  So, the SQL statements:
**
**       A GLOB B
**
** is implemented as glob(B,A).
*/
static void globFunc(sqlite3_context *context, int arg, sqlite3_value **argv){
  const unsigned char *zA = sqlite3_value_text(argv[0]);
  const unsigned char *zB = sqlite3_value_text(argv[1]);
  if( zA && zB ){
    sqlite3_result_int(context, patternCompare(zA, zB, &globInfo, 0));
  }
}

/*
** Implementation of the NULLIF(x,y) function.  The result is the first
** argument if the arguments are different.  The result is NULL if the
** arguments are equal to each other.

    { "upper",              1, 0, SQLITE_UTF8,    0, upperFunc  },
    { "lower",              1, 0, SQLITE_UTF8,    0, lowerFunc  },
    { "coalesce",          -1, 0, SQLITE_UTF8,    0, ifnullFunc },
    { "coalesce",           0, 0, SQLITE_UTF8,    0, 0          },
    { "coalesce",           1, 0, SQLITE_UTF8,    0, 0          },
    { "ifnull",             2, 0, SQLITE_UTF8,    1, ifnullFunc },
    { "random",            -1, 0, SQLITE_UTF8,    0, randomFunc },
    { "like",               2, 0, SQLITE_UTF8,    0, likeFunc   },
    { "like",               3, 0, SQLITE_UTF8,    0, likeFunc   },
    { "glob",               2, 0, SQLITE_UTF8,    0, globFunc   },
    { "nullif",             2, 0, SQLITE_UTF8,    1, nullifFunc },
    { "sqlite_version",     0, 0, SQLITE_UTF8,    0, versionFunc},
    { "quote",              1, 0, SQLITE_UTF8,    0, quoteFunc  },
    { "last_insert_rowid",  0, 1, SQLITE_UTF8,    0, last_insert_rowid },
    { "changes",            0, 1, SQLITE_UTF8,    0, changes    },
    { "total_changes",      0, 1, SQLITE_UTF8,    0, total_changes },
#ifdef SQLITE_SOUNDEX

      if( pFunc && aAggs[i].needCollSeq ){
        pFunc->needCollSeq = 1;
      }
    }
  }
  sqlite3RegisterDateTimeFunctions(db);
#ifdef SQLITE_SSE








  {










    sqlite3SseFunctions(db);











  }









#endif











}







}

**    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.6 2005/08/01 19:32:10 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <assert.h>

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

  assert( pH->htsize>0 );
  assert( (pH->htsize & (pH->htsize-1))==0 );
  h = hraw & (pH->htsize-1);
  insertElement(pH, &pH->ht[h], new_elem);
  new_elem->data = data;
  return 0;
}

}

**    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.6 2005/08/01 19:32:10 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.6 2005/08/01 19:32:10 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:

      sqlite3VdbeAddOp(v, OP_Return, 0, 0);

      /* The following code runs first because the GOTO at the very top
      ** of the program jumps to it.  Create the temporary table, then jump
      ** back up and execute the SELECT code above.
      */
      sqlite3VdbeChangeP2(v, iInitCode, sqlite3VdbeCurrentAddr(v));
      sqlite3VdbeAddOp(v, OP_OpenTemp, srcTab, 0);
      sqlite3VdbeAddOp(v, OP_SetNumColumns, srcTab, nColumn);
      sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop);
      sqlite3VdbeResolveLabel(v, iCleanup);
    }else{
      sqlite3VdbeChangeP2(v, iInitCode, sqlite3VdbeCurrentAddr(v));
    }
  }else{

      int idx = pIdx->aiColumn[i];
      if( idx==pTab->iPKey ){
        sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1);
      }else{
        sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1);
      }
    }
    jumpInst1 = sqlite3VdbeAddOp(v, OP_MakeRecord, pIdx->nColumn, (1<<24));
    sqlite3IndexAffinityStr(v, pIdx);

    /* Find out what action to take in case there is an indexing conflict */
    onError = pIdx->onError;
    if( onError==OE_None ) continue;  /* pIdx is not a UNIQUE index */
    if( overrideError!=OE_Default ){
      onError = overrideError;

          sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
        }
        seenReplace = 1;
        break;
      }
    }
    contAddr = sqlite3VdbeCurrentAddr(v);
    assert( contAddr<(1<<24) );
#if NULL_DISTINCT_FOR_UNIQUE
    sqlite3VdbeChangeP2(v, jumpInst1, contAddr | (1<<24));
#endif
    sqlite3VdbeChangeP2(v, jumpInst2, contAddr);
  }
}

/*
** This routine generates code to finish the INSERT or UPDATE operation

  int op           /* OP_OpenRead or OP_OpenWrite */
){
  int i;
  Index *pIdx;
  Vdbe *v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  sqlite3VdbeAddOp(v, OP_Integer, pTab->iDb, 0);
  sqlite3VdbeAddOp(v, op, base, pTab->tnum);
  VdbeComment((v, "# %s", pTab->zName));

  sqlite3VdbeAddOp(v, OP_SetNumColumns, base, pTab->nCol);
  for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
    sqlite3VdbeAddOp(v, OP_Integer, pIdx->iDb, 0);

    sqlite3VdbeOp3(v, op, i+base, pIdx->tnum,
                   (char*)&pIdx->keyInfo, P3_KEYINFO);
  }
  if( pParse->nTab<=base+i ){
    pParse->nTab = base+i;
  }
}

}

/* Hash score: 153 */
static int keywordCode(const char *z, int n){
  static const char zText[515] =
    "ABORTABLEFTEMPORARYADDATABASELECTHENDEFAULTRANSACTIONATURALTER"
    "AISEACHECKEYAFTEREFERENCESCAPELSEXCEPTRIGGEREGEXPLAINITIALLYAND"
    "EFERRABLEXCLUSIVEXISTSTATEMENTATTACHAVINGLOBEFOREIGNOREINDEXAUTOINCREMENT"
    "BEGINNERENAMEBETWEENOTNULLIKEBYCASCADEFERREDELETECASECOLLATECOLUMN"
    "COMMITCONFLICTCONSTRAINTERSECTCREATECROSSCURRENT_DATECURRENT_TIMESTAMP"
    "RAGMATCHDESCDETACHDISTINCTDROPRIMARYFAILIMITFROMFULLGROUPDATE"
    "IMMEDIATEINSERTINSTEADINTOFFSETISNULLJOINORDEREPLACEOUTERESTRICT"
    "RIGHTROLLBACKROWHENUNIONUNIQUEUSINGVACUUMVALUESVIEWHERE";

  static const unsigned char aHash[127] = {
      89,  79, 102,  88,   0,   4,   0,   0, 109,   0,  75,   0,   0,

      92,  43,   0,  90,   0, 101, 104,  94,   0,   0,  10,   0,   0,
     108,   0, 105, 100,   0,  28,  47,   0,  40,   0,   0,  63,  69,
       0,  62,  19,   0,   0,  32,  81,   0, 103,  72,   0,   0,  34,
       0,  60,  33,   0,   8,   0, 110,  37,  12,   0,  76,  39,  25,
      64,   0,   0,  31,  80,  52,  30,  49,  20,  86,   0,  35,   0,
      73,  26,   0,  70,   0,   0,   0,   0,  46,  65,  22,  85,  29,
      67,  84,   0,   1,   0,   9,  98,  57,  18,   0, 107,  74,  96,
      53,   6,  83,   0,   0,  48,  91,   0,  99,   0,  68,   0,   0,
      15,   0, 111,  50,  55,   0,   2,  54,   0, 106,
  };
  static const unsigned char aNext[111] = {
       0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,   0,   0,
       0,   0,   0,   0,   0,   0,   0,   0,  17,   0,   0,   0,   0,
       0,  11,   0,   0,   0,   7,   0,   5,  13,   0,   0,   0,   0,
       0,   0,   0,   0,   0,   0,  42,   0,   0,   0,   0,   0,   0,
       0,  16,   0,  23,  51,   0,   0,   0,   0,  44,  58,   0,   0,
       0,   0,   0,   0,   0,   0,  71,  41,   0,   0,  24,  59,  21,
       0,  78,   0,  66,   0,   0,  82,  45,   0,   0,   0,   0,   0,
       0,   0,  38,  93,  95,   0,   0,  97,   0,  14,  27,  77,   0,
      56,  87,   0,  36,   0,  61,   0,
  };
  static const unsigned char aLen[111] = {
       5,   5,   4,   4,   9,   2,   3,   8,   2,   6,   4,   3,   7,
      11,   2,   7,   5,   5,   4,   5,   3,   5,  10,   6,   4,   6,
       7,   6,   7,   9,   3,   3,  10,   9,   6,   9,   6,   6,   4,
       6,   3,   7,   6,   7,   5,  13,   2,   2,   5,   5,   6,   7,
       3,   7,   4,   4,   2,   7,   3,   8,   6,   4,   7,   6,   6,
       8,  10,   9,   6,   5,  12,  12,  17,   6,   5,   4,   6,   8,
       2,   4,   7,   4,   5,   4,   4,   5,   6,   9,   6,   7,   4,
       2,   6,   3,   6,   4,   5,   7,   5,   8,   5,   8,   3,   4,
       5,   6,   5,   6,   6,   4,   5,
  };
  static const unsigned short int aOffset[111] = {
       0,   4,   7,  10,  10,  14,  19,  21,  26,  27,  32,  34,  36,
      42,  51,  52,  57,  61,  65,  67,  71,  74,  78,  86,  91,  94,
      99, 105, 108, 113, 118, 122, 124, 133, 141, 146, 155, 160, 165,
     168, 170, 170, 174, 178, 180, 185, 187, 189, 198, 201, 205, 211,
     217, 217, 220, 223, 227, 229, 230, 234, 241, 247, 251, 258, 264,
     270, 278, 285, 294, 300, 305, 317, 317, 333, 337, 342, 346, 352,
     353, 360, 363, 370, 373, 378, 382, 386, 389, 395, 404, 410, 417,
     420, 420, 423, 426, 432, 436, 440, 447, 451, 459, 464, 472, 474,
     478, 483, 489, 494, 500, 506, 509,
  };
  static const unsigned char aCode[111] = {
    TK_ABORT,      TK_TABLE,      TK_JOIN_KW,    TK_TEMP,       TK_TEMP,       
    TK_OR,         TK_ADD,        TK_DATABASE,   TK_AS,         TK_SELECT,     
    TK_THEN,       TK_END,        TK_DEFAULT,    TK_TRANSACTION,TK_ON,         
    TK_JOIN_KW,    TK_ALTER,      TK_RAISE,      TK_EACH,       TK_CHECK,      
    TK_KEY,        TK_AFTER,      TK_REFERENCES, TK_ESCAPE,     TK_ELSE,       
    TK_EXCEPT,     TK_TRIGGER,    TK_LIKE_KW,    TK_EXPLAIN,    TK_INITIALLY,  
    TK_ALL,        TK_AND,        TK_DEFERRABLE, TK_EXCLUSIVE,  TK_EXISTS,     
    TK_STATEMENT,  TK_ATTACH,     TK_HAVING,     TK_LIKE_KW,    TK_BEFORE,     
    TK_FOR,        TK_FOREIGN,    TK_IGNORE,     TK_REINDEX,    TK_INDEX,      
    TK_AUTOINCR,   TK_TO,         TK_IN,         TK_BEGIN,      TK_JOIN_KW,    
    TK_RENAME,     TK_BETWEEN,    TK_NOT,        TK_NOTNULL,    TK_NULL,       
    TK_LIKE_KW,    TK_BY,         TK_CASCADE,    TK_ASC,        TK_DEFERRED,   
    TK_DELETE,     TK_CASE,       TK_COLLATE,    TK_COLUMNKW,   TK_COMMIT,     
    TK_CONFLICT,   TK_CONSTRAINT, TK_INTERSECT,  TK_CREATE,     TK_JOIN_KW,    
    TK_CTIME_KW,   TK_CTIME_KW,   TK_CTIME_KW,   TK_PRAGMA,     TK_MATCH,      
    TK_DESC,       TK_DETACH,     TK_DISTINCT,   TK_IS,         TK_DROP,       
    TK_PRIMARY,    TK_FAIL,       TK_LIMIT,      TK_FROM,       TK_JOIN_KW,    
    TK_GROUP,      TK_UPDATE,     TK_IMMEDIATE,  TK_INSERT,     TK_INSTEAD,    
    TK_INTO,       TK_OF,         TK_OFFSET,     TK_SET,        TK_ISNULL,     
    TK_JOIN,       TK_ORDER,      TK_REPLACE,    TK_JOIN_KW,    TK_RESTRICT,   
    TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,        TK_WHEN,       TK_UNION,      
    TK_UNIQUE,     TK_USING,      TK_VACUUM,     TK_VALUES,     TK_VIEW,       
    TK_WHERE,      
  };
  int h, i;
  if( n<2 ) return TK_ID;
  h = ((sqlite3UpperToLower[((unsigned char*)z)[0]]*4) ^
      (sqlite3UpperToLower[((unsigned char*)z)[n-1]]*3) ^
      n) % 127;
  for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){

**
*************************************************************************
** 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.6 2005/08/01 19:32:10 rmsimpson Exp $
*/

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

/*

    }
  }else if( pzErrMsg ){
    *pzErrMsg = 0;
  }

  return rc;
}

}

**
*************************************************************************
** 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.6 2005/08/01 19:32:10 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>

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

const char *sqlite3ErrStr(int rc){
  const char *z;
  switch( rc ){
    case SQLITE_ROW:
    case SQLITE_DONE:
    case SQLITE_OK:         z = "not an error";                          break;
    case SQLITE_ERROR:      z = "SQL logic error or missing database";   break;
    case SQLITE_INTERNAL:   z = "internal SQLite implementation flaw";   break;
    case SQLITE_PERM:       z = "access permission denied";              break;
    case SQLITE_ABORT:      z = "callback requested query abort";        break;
    case SQLITE_BUSY:       z = "database is locked";                    break;
    case SQLITE_LOCKED:     z = "database table is locked";              break;
    case SQLITE_NOMEM:      z = "out of memory";                         break;
    case SQLITE_READONLY:   z = "attempt to write a readonly database";  break;
    case SQLITE_INTERRUPT:  z = "interrupted";                           break;
    case SQLITE_IOERR:      z = "disk I/O error";                        break;
    case SQLITE_CORRUPT:    z = "database disk image is malformed";      break;
    case SQLITE_NOTFOUND:   z = "table or record not found";             break;
    case SQLITE_FULL:       z = "database is full";                      break;
    case SQLITE_CANTOPEN:   z = "unable to open database file";          break;
    case SQLITE_PROTOCOL:   z = "database locking protocol failure";     break;
    case SQLITE_EMPTY:      z = "table contains no data";                break;
    case SQLITE_SCHEMA:     z = "database schema has changed";           break;
    case SQLITE_TOOBIG:     z = "too much data for one table row";       break;
    case SQLITE_CONSTRAINT: z = "constraint failed";                     break;
    case SQLITE_MISMATCH:   z = "datatype mismatch";                     break;
    case SQLITE_MISUSE:     z = "library routine called out of sequence";break;
    case SQLITE_NOLFS:      z = "kernel lacks large file support";       break;
    case SQLITE_AUTH:       z = "authorization denied";                  break;
    case SQLITE_FORMAT:     z = "auxiliary database format error";       break;
    case SQLITE_RANGE:      z = "bind or column index out of range";     break;

  if( prior + delay > timeout ){
    delay = timeout - prior;
    if( delay<=0 ) return 0;
  }
  sqlite3OsSleep(delay);
  return 1;
#else
  int timeout = (int)Timeout;
  if( (count+1)*1000 > timeout ){
    return 0;
  }
  sqlite3OsSleep(1000);
  return 1;
#endif
}




















/*
** This routine sets the busy callback for an Sqlite database to the
** given callback function with the given argument.
*/
int sqlite3_busy_handler(
  sqlite3 *db,
  int (*xBusy)(void*,int),
  void *pArg
){
  if( sqlite3SafetyCheck(db) ){
    return SQLITE_MISUSE;
  }
  db->busyHandler.xFunc = xBusy;
  db->busyHandler.pArg = pArg;

  return SQLITE_OK;
}

#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
/*
** This routine sets the progress callback for an Sqlite database to the
** given callback function with the given argument. The progress callback will

    }else{
      sqlite3ExpirePreparedStatements(db);
    }
  }

  p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
  if( p==0 ) return SQLITE_NOMEM;

  p->xFunc = xFunc;
  p->xStep = xStep;
  p->xFinalize = xFinal;
  p->pUserData = pUserData;
  return SQLITE_OK;
}
#ifndef SQLITE_OMIT_UTF16

/*
** This routine is called to create a connection to a database BTree
** driver.  If zFilename is the name of a file, then that file is
** opened and used.  If zFilename is the magic name ":memory:" then
** the database is stored in memory (and is thus forgotten as soon as
** the connection is closed.)  If zFilename is NULL then the database
** is for temporary use only and is deleted as soon as the connection
** is closed.
**
** A temporary database can be either a disk file (that is automatically
** deleted when the file is closed) or a set of red-black trees held in memory,
** depending on the values of the TEMP_STORE compile-time macro and the
** db->temp_store variable, according to the following chart:
**
**       TEMP_STORE     db->temp_store     Location of temporary database
**       ----------     --------------     ------------------------------
**           0               any             file
**           1                1              file

** by the next COMMIT or ROLLBACK.
**
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
*/
int sqlite3_get_autocommit(sqlite3 *db){
  return db->autoCommit;
}

}

#pragma unmanaged
extern "C"
{
/* Automatically generated.  Do not edit */
/* See the mkopcodec.awk script for details. */
#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
const char *const sqlite3OpcodeNames[] = { "?",
 /*   1 */ "MemLoad",
 /*   2 */ "Column",
 /*   3 */ "SetCookie",
 /*   4 */ "IfMemPos",
 /*   5 */ "MoveGt",
 /*   6 */ "AggFocus",
 /*   7 */ "RowKey",
 /*   8 */ "AggNext",
 /*   9 */ "OpenWrite",
 /*  10 */ "If",
 /*  11 */ "Pop",
 /*  12 */ "AggContextPush",
 /*  13 */ "CollSeq",
 /*  14 */ "OpenRead",
 /*  15 */ "Expire",
 /*  16 */ "SortReset",
 /*  17 */ "AutoCommit",
 /*  18 */ "Sort",
 /*  19 */ "ListRewind",
 /*  20 */ "IntegrityCk",
 /*  21 */ "SortInsert",
 /*  22 */ "Function",
 /*  23 */ "Noop",
 /*  24 */ "Return",
 /*  25 */ "NewRowid",
 /*  26 */ "Variable",
 /*  27 */ "String",
 /*  28 */ "ParseSchema",
 /*  29 */ "AggFunc",
 /*  30 */ "Close",
 /*  31 */ "ListWrite",
 /*  32 */ "CreateIndex",
 /*  33 */ "IsUnique",
 /*  34 */ "IdxIsNull",
 /*  35 */ "NotFound",
 /*  36 */ "MustBeInt",
 /*  37 */ "Halt",
 /*  38 */ "Rowid",
 /*  39 */ "IdxLT",
 /*  40 */ "AddImm",
 /*  41 */ "Statement",
 /*  42 */ "RowData",
 /*  43 */ "MemMax",
 /*  44 */ "Push",
 /*  45 */ "NotExists",
 /*  46 */ "OpenTemp",
 /*  47 */ "MemIncr",
 /*  48 */ "Gosub",
 /*  49 */ "AggSet",
 /*  50 */ "Integer",
 /*  51 */ "SortNext",
 /*  52 */ "Prev",
 /*  53 */ "CreateTable",
 /*  54 */ "Last",
 /*  55 */ "IdxRowid",
 /*  56 */ "ResetCount",
 /*  57 */ "Callback",
 /*  58 */ "ContextPush",
 /*  59 */ "DropTrigger",
 /*  60 */ "DropIndex",
 /*  61 */ "IdxGE",
 /*  62 */ "Or",
 /*  63 */ "And",
 /*  64 */ "Not",
 /*  65 */ "IdxDelete",
 /*  66 */ "Vacuum",
 /*  67 */ "MoveLe",
 /*  68 */ "IsNull",
 /*  69 */ "NotNull",
 /*  70 */ "Ne",
 /*  71 */ "Eq",
 /*  72 */ "Gt",
 /*  73 */ "Le",
 /*  74 */ "Lt",
 /*  75 */ "Ge",
 /*  76 */ "IfNot",
 /*  77 */ "BitAnd",
 /*  78 */ "BitOr",
 /*  79 */ "ShiftLeft",
 /*  80 */ "ShiftRight",
 /*  81 */ "Add",
 /*  82 */ "Subtract",
 /*  83 */ "Multiply",
 /*  84 */ "Divide",
 /*  85 */ "Remainder",
 /*  86 */ "Concat",
 /*  87 */ "Negative",
 /*  88 */ "DropTable",
 /*  89 */ "BitNot",
 /*  90 */ "String8",
 /*  91 */ "MakeRecord",
 /*  92 */ "Delete",
 /*  93 */ "AggContextPop",
 /*  94 */ "ListRead",
 /*  95 */ "ListReset",
 /*  96 */ "Dup",
 /*  97 */ "Goto",
 /*  98 */ "Clear",
 /*  99 */ "IdxGT",
 /* 100 */ "MoveLt",
 /* 101 */ "VerifyCookie",
 /* 102 */ "Pull",
 /* 103 */ "SetNumColumns",
 /* 104 */ "AbsValue",
 /* 105 */ "Transaction",
 /* 106 */ "AggGet",
 /* 107 */ "ContextPop",
 /* 108 */ "Next",
 /* 109 */ "AggInit",
 /* 110 */ "IdxInsert",
 /* 111 */ "Distinct",
 /* 112 */ "AggReset",
 /* 113 */ "Insert",
 /* 114 */ "Destroy",
 /* 115 */ "ReadCookie",
 /* 116 */ "ForceInt",
 /* 117 */ "OpenPseudo",
 /* 118 */ "Null",
 /* 119 */ "Blob",
 /* 120 */ "MemStore",
 /* 121 */ "Rewind",
 /* 122 */ "MoveGe",
 /* 123 */ "Found",
 /* 124 */ "NullRow",
 /* 125 */ "NotUsed_125",
 /* 126 */ "NotUsed_126",
 /* 127 */ "NotUsed_127",
 /* 128 */ "Real",
 /* 129 */ "HexBlob",


};
#endif

}

/* Automatically generated.  Do not edit */
/* See the mkopcodeh.awk script for details */
#define OP_MemLoad                              1
#define OP_HexBlob                            129   /* same as TK_BLOB     */
#define OP_Column                               2
#define OP_SetCookie                            3
#define OP_IfMemPos                             4
#define OP_Real                               128   /* same as TK_FLOAT    */
#define OP_MoveGt                               5
#define OP_Ge                                  75   /* same as TK_GE       */
#define OP_AggFocus                             6
#define OP_RowKey                               7
#define OP_AggNext                              8
#define OP_Eq                                  71   /* same as TK_EQ       */
#define OP_OpenWrite                            9
#define OP_NotNull                             69   /* same as TK_NOTNULL  */
#define OP_If                                  10

#define OP_String8                             90   /* same as TK_STRING   */
#define OP_Pop                                 11
#define OP_AggContextPush                      12
#define OP_CollSeq                             13
#define OP_OpenRead                            14
#define OP_Expire                              15
#define OP_SortReset                           16
#define OP_AutoCommit                          17
#define OP_Gt                                  72   /* same as TK_GT       */
#define OP_Sort                                18
#define OP_ListRewind                          19
#define OP_IntegrityCk                         20
#define OP_SortInsert                          21
#define OP_Function                            22
#define OP_And                                 63   /* same as TK_AND      */
#define OP_Subtract                            82   /* same as TK_MINUS    */
#define OP_Noop                                23
#define OP_Return                              24
#define OP_Remainder                           85   /* same as TK_REM      */
#define OP_NewRowid                            25
#define OP_Multiply                            83   /* same as TK_STAR     */
#define OP_Variable                            26
#define OP_String                              27
#define OP_ParseSchema                         28
#define OP_AggFunc                             29
#define OP_Close                               30
#define OP_ListWrite                           31
#define OP_CreateIndex                         32
#define OP_IsUnique                            33
#define OP_IdxIsNull                           34
#define OP_NotFound                            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_Or                                  62   /* same as TK_OR       */
#define OP_NotExists                           45
#define OP_OpenTemp                            46
#define OP_MemIncr                             47
#define OP_Gosub                               48
#define OP_Divide                              84   /* same as TK_SLASH    */
#define OP_AggSet                              49
#define OP_Integer                             50

#define OP_SortNext                            51
#define OP_Prev                                52
#define OP_Concat                              86   /* same as TK_CONCAT   */
#define OP_BitAnd                              77   /* same as TK_BITAND   */
#define OP_CreateTable                         53
#define OP_Last                                54
#define OP_IsNull                              68   /* same as TK_ISNULL   */
#define OP_IdxRowid                            55

#define OP_ShiftRight                          80   /* same as TK_RSHIFT   */
#define OP_ResetCount                          56

#define OP_Callback                            57
#define OP_ContextPush                         58
#define OP_DropTrigger                         59
#define OP_DropIndex                           60
#define OP_IdxGE                               61
#define OP_IdxDelete                           65
#define OP_Vacuum                              66
#define OP_MoveLe                              67
#define OP_IfNot                               76
#define OP_DropTable                           88
#define OP_MakeRecord                          91

#define OP_Delete                              92
#define OP_AggContextPop                       93
#define OP_ListRead                            94
#define OP_ListReset                           95
#define OP_ShiftLeft                           79   /* same as TK_LSHIFT   */
#define OP_Dup                                 96
#define OP_Goto                                97

#define OP_Clear                               98
#define OP_IdxGT                               99
#define OP_MoveLt                             100
#define OP_Le                                  73   /* same as TK_LE       */
#define OP_VerifyCookie                       101
#define OP_Pull                               102

#define OP_Not                                 64   /* same as TK_NOT      */
#define OP_SetNumColumns                      103
#define OP_AbsValue                           104
#define OP_Transaction                        105
#define OP_Negative                            87   /* same as TK_UMINUS   */
#define OP_Ne                                  70   /* same as TK_NE       */
#define OP_AggGet                             106
#define OP_ContextPop                         107
#define OP_BitOr                               78   /* same as TK_BITOR    */
#define OP_Next                               108
#define OP_AggInit                            109
#define OP_IdxInsert                          110
#define OP_Distinct                           111
#define OP_Lt                                  74   /* same as TK_LT       */
#define OP_AggReset                           112
#define OP_Insert                             113
#define OP_Destroy                            114
#define OP_ReadCookie                         115
#define OP_ForceInt                           116


#define OP_OpenPseudo                         117
#define OP_Null                               118
#define OP_Blob                               119
#define OP_Add                                 81   /* same as TK_PLUS     */
#define OP_MemStore                           120
#define OP_Rewind                             121
#define OP_MoveGe                             122
#define OP_BitNot                              89   /* same as TK_BITNOT   */
#define OP_Found                              123
#define OP_NullRow                            124

/* The following opcode values are never used */
#define OP_NotUsed_125                        125
#define OP_NotUsed_126                        126
#define OP_NotUsed_127                        127

#define NOPUSH_MASK_0 65400
#define NOPUSH_MASK_1 61871
#define NOPUSH_MASK_2 64446
#define NOPUSH_MASK_3 65363
#define NOPUSH_MASK_4 65535
#define NOPUSH_MASK_5 46015
#define NOPUSH_MASK_6 64254
#define NOPUSH_MASK_7 7987
#define NOPUSH_MASK_8 0
#define NOPUSH_MASK_9 0

** lacks the fcntl() system call.  So redefine fcntl() to be something
** that always succeeds.  This means that locking does not occur under
** DJGPP.  But its DOS - what did you expect?
*/
#ifdef __DJGPP__
# define fcntl(A,B,C) 0
#endif

/*
** Macros used to determine whether or not to use threads.  The
** SQLITE_UNIX_THREADS macro is defined if we are synchronizing for
** Posix threads and SQLITE_W32_THREADS is defined if we are
** synchronizing using Win32 threads.
*/
#if defined(THREADSAFE) && THREADSAFE
# include <pthread.h>
# define SQLITE_UNIX_THREADS 1
#endif


/*
** Include code that is common to all os_*.c files
*/
#include "os_common.h"










#if defined(THREADSAFE) && THREADSAFE && defined(__linux__)










#define getpid pthread_self




#endif

/*
** Here is the dirt on POSIX advisory locks:  ANSI STD 1003.1 (1996)
** section 6.5.2.2 lines 483 through 490 specify that when a process
** sets or clears a lock, that operation overrides any prior locks set
** by the same process.  It does not explicitly say so, but this implies

*/
struct threadTestData {
  int fd;                /* File to be locked */
  struct flock lock;     /* The locking operation */
  int result;            /* Result of the locking operation */
};




























































/*
** The testThreadLockingBehavior() routine launches two separate
** threads on this routine.  This routine attempts to lock a file
** descriptor then returns.  The success or failure of that attempt
** allows the testThreadLockingBehavior() procedure to determine
** whether or not threads can override each others locks.
*/

  const char *zFilename,
  OsFile *id,
  int *pReadonly
){
  int rc;
  assert( !id->isOpen );
  id->dirfd = -1;

  id->h = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY,
                          SQLITE_DEFAULT_FILE_PERMISSIONS);
  if( id->h<0 ){
#ifdef EISDIR
    if( errno==EISDIR ){
      return SQLITE_CANTOPEN;
    }

*/
int sqlite3OsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){
  int rc;
  assert( !id->isOpen );
  if( access(zFilename, 0)==0 ){
    return SQLITE_CANTOPEN;
  }

  id->dirfd = -1;
  id->h = open(zFilename,
                O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, 0600);

  if( id->h<0 ){
    return SQLITE_CANTOPEN;
  }
  sqlite3OsEnterMutex();
  rc = findLockInfo(id->h, &id->pLock, &id->pOpen);
  sqlite3OsLeaveMutex();
  if( rc ){

** On success, write the file handle into *id and return SQLITE_OK.
**
** On failure, return SQLITE_CANTOPEN.
*/
int sqlite3OsOpenReadOnly(const char *zFilename, OsFile *id){
  int rc;
  assert( !id->isOpen );

  id->dirfd = -1;
  id->h = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY);
  if( id->h<0 ){
    return SQLITE_CANTOPEN;
  }
  sqlite3OsEnterMutex();
  rc = findLockInfo(id->h, &id->pLock, &id->pOpen);

  OsFile *id
){
  if( !id->isOpen ){
    /* Do not open the directory if the corresponding file is not already
    ** open. */
    return SQLITE_CANTOPEN;
  }

  assert( id->dirfd<0 );
  id->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0);
  if( id->dirfd<0 ){
    return SQLITE_CANTOPEN; 
  }
  TRACE3("OPENDIR %-3d %s\n", id->dirfd, zDirname);
  return SQLITE_OK;

** non-zero.  If the file is unlocked or holds only SHARED locks, then
** return zero.
*/
int sqlite3OsCheckReservedLock(OsFile *id){
  int r = 0;

  assert( id->isOpen );

  sqlite3OsEnterMutex(); /* Needed because id->pLock is shared across threads */

  /* Check if a thread in this process holds such a lock */
  if( id->pLock->locktype>SHARED_LOCK ){
    r = 1;
  }

  struct flock lock;
  int s;

  assert( id->isOpen );
  TRACE7("LOCK    %d %s was %s(%s,%d) pid=%d\n", id->h, locktypeName(locktype), 
      locktypeName(id->locktype), locktypeName(pLock->locktype), pLock->cnt
      ,getpid() );


  /* If there is already a lock of this type or more restrictive on the
  ** OsFile, do nothing. Don't use the end_lock: exit path, as
  ** sqlite3OsEnterMutex() hasn't been called yet.
  */
  if( id->locktype>=locktype ){
    TRACE3("LOCK    %d %s ok (already held)\n", id->h, locktypeName(locktype));

    id->locktype = SHARED_LOCK;
    pLock->cnt++;
    id->pOpen->nLock++;
    goto end_lock;
  }

  lock.l_len = 1L;

  lock.l_whence = SEEK_SET;

  /* A PENDING lock is needed before acquiring a SHARED lock and before
  ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
  ** be released.
  */
  if( locktype==SHARED_LOCK 

    lock.l_len = SHARED_SIZE;
    s = fcntl(id->h, F_SETLK, &lock);

    /* Drop the temporary PENDING lock */
    lock.l_start = PENDING_BYTE;
    lock.l_len = 1L;
    lock.l_type = F_UNLCK;
    fcntl(id->h, F_SETLK, &lock);



    if( s ){
      rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
    }else{
      id->locktype = SHARED_LOCK;
      id->pOpen->nLock++;
      pLock->cnt = 1;
    }

  struct lockInfo *pLock;
  struct flock lock;
  int rc = SQLITE_OK;

  assert( id->isOpen );
  TRACE7("UNLOCK  %d %d was %d(%d,%d) pid=%d\n", id->h, locktype, id->locktype, 
      id->pLock->locktype, id->pLock->cnt, getpid());


  assert( locktype<=SHARED_LOCK );
  if( id->locktype<=locktype ){
    return SQLITE_OK;
  }
  sqlite3OsEnterMutex();
  pLock = id->pLock;

        rc = SQLITE_IOERR;
      }
    }
    lock.l_type = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = PENDING_BYTE;
    lock.l_len = 2L;  assert( PENDING_BYTE+1==RESERVED_BYTE );
    fcntl(id->h, F_SETLK, &lock);
    pLock->locktype = SHARED_LOCK;



  }
  if( locktype==NO_LOCK ){
    struct openCnt *pOpen;

    /* Decrement the shared lock counter.  Release the lock using an
    ** OS call only when all threads in this same process have released
    ** the lock.
    */
    pLock->cnt--;
    if( pLock->cnt==0 ){
      lock.l_type = F_UNLCK;
      lock.l_whence = SEEK_SET;
      lock.l_start = lock.l_len = 0L;
      fcntl(id->h, F_SETLK, &lock);
      pLock->locktype = NO_LOCK;



    }

    /* Decrement the count of locks against this same file.  When the
    ** count reaches zero, close any other file descriptors whose close
    ** was deferred because of outstanding locks.
    */
    pOpen = id->pOpen;

}

/*
** Close a file.
*/
int sqlite3OsClose(OsFile *id){
  if( !id->isOpen ) return SQLITE_OK;

  sqlite3OsUnlock(id, NO_LOCK);
  if( id->dirfd>=0 ) close(id->dirfd);
  id->dirfd = -1;
  sqlite3OsEnterMutex();
  if( id->pOpen->nLock ){
    /* If there are outstanding locks, do not actually close the file just
    ** yet because that would clear those locks.  Instead, add the file

** standard include files.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>












/*
** The OsFile structure is a operating-system independing representation
** of an open file handle.  It is defined differently for each architecture.
**
** This is the definition for Unix.
**
** OsFile.locktype takes one of the values SHARED_LOCK, RESERVED_LOCK,
** PENDING_LOCK or EXCLUSIVE_LOCK.
*/
typedef struct OsFile OsFile;
struct OsFile {
  struct Pager *pPager;     /* The pager that owns this OsFile.  Might be 0 */
  struct openCnt *pOpen;    /* Info about all open fd's on this inode */
  struct lockInfo *pLock;   /* Info about locks on this inode */
  int h;                    /* The file descriptor */
  unsigned char locktype;   /* The type of lock held on this fd */
  unsigned char isOpen;     /* True if needs to be closed */
  unsigned char fullSync;   /* Use F_FULLSYNC if available */
  int dirfd;                /* File descriptor for the directory */



};

/*
** A macro to set the OsFile.fullSync flag, if it exists.
*/
#define SET_FULLSYNC(x,y)  ((x).fullSync = (y))

extern "C"
{
/*
** 2004 May 22
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:

    *prNow = sqlite3_current_time/86400.0 + 2440587.5;
  }
#endif
  return 0;
}

#endif /* OS_WIN */

}

extern "C"
{
/*
** 2005 April 1 - Nuno Lucas
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:

** 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.6 2005/08/01 19:32:10 rmsimpson Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
#include "os.h"
#include "pager.h"
#include <assert.h>
#include <string.h>

  if( pgno>(unsigned)pPager->dbSize ){
    return SQLITE_OK;
  }
  if( useCksum ){
    rc = read32bits(jfd, &cksum);
    if( rc ) return rc;
    pPager->journalOff += 4;
    if( pager_cksum(pPager, pgno, (char *)aData)!=cksum ){
      return SQLITE_DONE;
    }
  }

  assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );

  /* If the pager is in RESERVED state, then there must be a copy of this

  if( pPager->dbSize>=0 ){
    return pPager->dbSize;
  }
  if( sqlite3OsFileSize(&pPager->fd, &n)!=SQLITE_OK ){
    pPager->errMask |= PAGER_ERR_DISK;
    return 0;
  }



  n /= pPager->pageSize;

  if( !MEMDB && n==PENDING_BYTE/pPager->pageSize ){
    n++;
  }
  if( pPager->state!=PAGER_UNLOCK ){
    pPager->dbSize = n;
  }
  return n;

}
#else
#define memoryTruncate(p)
#endif

/*
** Try to obtain a lock on a file.  Invoke the busy callback if the lock
** is currently not available.  Repeate until the busy callback returns
** 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;
  assert( PAGER_SHARED==SHARED_LOCK );
  assert( PAGER_RESERVED==RESERVED_LOCK );
  assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
  if( pPager->state>=locktype ){
    rc = SQLITE_OK;
  }else{
    int busy = 1;
    BusyHandler *pH;
    do {
      rc = sqlite3OsLock(&pPager->fd, locktype);
    }while( rc==SQLITE_BUSY && 
        (pH = pPager->pBusyHandler)!=0 && 
        pH->xFunc && pH->xFunc(pH->pArg, busy++)
    );
    if( rc==SQLITE_OK ){
      pPager->state = locktype;
    }
  }
  return rc;
}

          pHist->pOrig = (u8 *)sqliteMallocRaw( pPager->pageSize );
          if( pHist->pOrig ){
            memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize);
          }
        }else{
          u32 cksum;
          CODEC(pPager, pData, pPg->pgno, 7);
          cksum = pager_cksum(pPager, pPg->pgno, (char *)pData);
          saved = *(u32*)PGHDR_TO_EXTRA(pPg, pPager);
          store32bits(cksum, pPg, pPager->pageSize);
          szPg = pPager->pageSize+8;
          store32bits(pPg->pgno, pPg, -4);
          rc = sqlite3OsWrite(&pPager->jfd, &((char*)pData)[-4], szPg);
          pPager->journalOff += szPg;
          TRACE4("JOURNAL %d page %d needSync=%d\n",

    sqlite3DebugPrintf("PAGE %3d addr=%p nRef=%d\n", 
       pPg->pgno, PGHDR_TO_DATA(pPg), pPg->nRef);
  }
}
#endif

#endif /* SQLITE_OMIT_DISKIO */

}

**    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.6 2005/08/01 19:32:12 rmsimpson Exp $
*/

/*
** The default size of a database page.
*/
#ifndef SQLITE_DEFAULT_PAGE_SIZE
# define SQLITE_DEFAULT_PAGE_SIZE 1024

#pragma unmanaged
extern "C"
{
/* Driver template for the LEMON parser generator.
** The author disclaims copyright to this source code.
*/
/* First off, code is include which follows the "include" declaration
** in the input file. */
#include <stdio.h>
////#line 33 "parse.y"

#include "sqliteInt.h"
#include "parse.h"

/*
** An instance of this structure holds information about the
** LIMIT clause of a SELECT statement.
*/
struct LimitVal {
  Expr *pLimit;    /* The LIMIT expression.  NULL if there is no limit */
  Expr *pOffset;   /* The OFFSET expression.  NULL if there is none */
};

/*
** An instance of this structure is used to store the LIKE,
** GLOB, NOT LIKE, and NOT GLOB operators.
*/
struct LikeOp {
  Token operat0r;  /* "like" or "glob" or "regexp" */
  int not;         /* True if the NOT keyword is present */
};

/*
** An instance of the following structure describes the event of a
** TRIGGER.  "a" is the event type, one of TK_UPDATE, TK_INSERT,
** TK_DELETE, or TK_INSTEAD.  If the event is of the form

**    sqlite3ParserARG_FETCH     Code to extract %extra_argument from yypParser
**    YYNSTATE           the combined number of states.
**    YYNRULE            the number of rules in the grammar
**    YYERRORSYMBOL      is the code number of the error symbol.  If not
**                       defined, then do no error processing.
*/
#define YYCODETYPE unsigned char
#define YYNOCODE 241
#define YYACTIONTYPE unsigned short int
#define sqlite3ParserTOKENTYPE Token
typedef union {
  sqlite3ParserTOKENTYPE yy0;
  Expr* yy2;
  struct {int value; int mask;} yy47;
  SrcList* yy67;
  ExprList* yy82;
  struct AttachKey yy132;
  struct TrigEvent yy210;
  IdList* yy240;
  struct LimitVal yy244;
  Token yy258;
  TriggerStep* yy347;




  int yy412;
  struct LikeOp yy438;
  Select* yy459;
  int yy481;
} YYMINORTYPE;
#define YYSTACKDEPTH 100
#define sqlite3ParserARG_SDECL Parse *pParse;
#define sqlite3ParserARG_PDECL ,Parse *pParse
#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
#define sqlite3ParserARG_STORE yypParser->pParse = pParse
#define YYNSTATE 565
#define YYNRULE 305
#define YYERRORSYMBOL 141
#define YYERRSYMDT yy481
#define YYFALLBACK 1
#define YY_NO_ACTION      (YYNSTATE+YYNRULE+2)
#define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)
#define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)

/* Next are that tables used to determine what action to take based on the
** current state and lookahead token.  These tables are used to implement

**  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 */   259,   65,  257,  112,  114,  110,  116,   66,  122,  124,
 /*    10 */   126,  128,  130,  132,  134,  136,  138,  140,  568,  142,
 /*    20 */   150,  122,  124,  126,  128,  130,  132,  134,  136,  138,
 /*    30 */   140,  130,  132,  134,  136,  138,  140,  108,   94,  143,
 /*    40 */   153,  158,  163,  152,  157,  118,  120,  112,  114,  110,
 /*    50 */   116,   72,  122,  124,  126,  128,  130,  132,  134,  136,
 /*    60 */   138,  140,    7,  106,  219,  258,  122,  124,  126,  128,
 /*    70 */   130,  132,  134,  136,  138,  140,  367,   13,    9,  369,
 /*    80 */   376,  381,  142,  871,    1,  564,   92,   27,    4,  399,
 /*    90 */   363,  384,  844,  341,  291,   28,   10,   95,  398,   33,
 /*   100 */   108,   94,  143,  153,  158,  163,  152,  157,  118,  120,
 /*   110 */   112,  114,  110,  116,   96,  122,  124,  126,  128,  130,
 /*   120 */   132,  134,  136,  138,  140,  456,  565,  142,  395,  305,
 /*   130 */   101,  102,  103,  288,   75,  394,    3,  563,  231,  275,
 /*   140 */    14,   15,  575,  597,  437,  108,   94,  143,  153,  158,
 /*   150 */   163,  152,  157,  118,  120,  112,  114,  110,  116,   13,
 /*   160 */   122,  124,  126,  128,  130,  132,  134,  136,  138,  140,
 /*   170 */   573,   77,  142,  223,  232,   13,  490,  462,  452,  167,
 /*   180 */   306,  169,  170,  276,  254,    3,  563,   81,  277,  183,
 /*   190 */   108,   94,  143,  153,  158,  163,  152,  157,  118,  120,
 /*   200 */   112,  114,  110,  116,   52,  122,  124,  126,  128,  130,
 /*   210 */   132,  134,  136,  138,  140,   48,   54,  799,  448,   51,
 /*   220 */   797,   77,   14,   15,   49,  363,  134,  136,  138,  140,
 /*   230 */    16,   17,   18,   32,   33,   50,  308,  197,   14,   15,
 /*   240 */   367,  261,   13,  369,  376,  381,  142,   37,  337,   40,
 /*   250 */    59,   67,   69,  301,  332,  384,  364,  397,  259,  807,
 /*   260 */   257,  334,   51,  193,  108,   94,  143,  153,  158,  163,
 /*   270 */   152,  157,  118,  120,  112,  114,  110,  116,  262,  122,
 /*   280 */   124,  126,  128,  130,  132,  134,  136,  138,  140,   13,
 /*   290 */   171,  142,   40,   59,   67,   69,  301,  332,  642,  148,
 /*   300 */   365,  159,  164,  261,  334,   14,   15,   44,   45,  108,
 /*   310 */    94,  143,  153,  158,  163,  152,  157,  118,  120,  112,
 /*   320 */   114,  110,  116,  258,  122,  124,  126,  128,  130,  132,
 /*   330 */   134,  136,  138,  140,  148,  218,  159,  164,  184,   12,
 /*   340 */   284,  417,   48,  360,  358,  293,  290,  347,  352,  353,
 /*   350 */   289,   49,   14,   15,  688,    2,   96,  148,    4,  159,
 /*   360 */   164,  257,   50,  530,   46,  142,  367,  155,  165,  369,
 /*   370 */   376,  381,   13,  576,   47,  167,   75,  169,  170,  554,
 /*   380 */   172,  384,  207,  108,   94,  143,  153,  158,  163,  152,
 /*   390 */   157,  118,  120,  112,  114,  110,  116,  154,  122,  124,
 /*   400 */   126,  128,  130,  132,  134,  136,  138,  140,  299,  354,
 /*   410 */   350,  352,  353,   96,   96,   13,   34,   20,  294,  362,
 /*   420 */   345,  144,  581,  167,  258,  169,  170,  821,  142,  558,
 /*   430 */   213,  244,  254,   75,   75,   14,   15,  172,  186,  167,
 /*   440 */   533,  169,  170,  146,  147,  417,  108,   94,  143,  153,
 /*   450 */   158,  163,  152,  157,  118,  120,  112,  114,  110,  116,
 /*   460 */    96,  122,  124,  126,  128,  130,  132,  134,  136,  138,
 /*   470 */   140,  145,  354,  142,   22,  239,  383,  589,   14,   15,
 /*   480 */    75,   36,  336,  419,  172,  187,  842,  213,  528,  582,
 /*   490 */   331,  108,   94,  143,  153,  158,  163,  152,  157,  118,
 /*   500 */   120,  112,  114,  110,  116,  249,  122,  124,  126,  128,
 /*   510 */   130,  132,  134,  136,  138,  140,  306,  661,  142,  327,
 /*   520 */   574,  849,  148,   11,  159,  164,  309,  316,  318,  168,
 /*   530 */    42,  327,  666,  327,  212,  393,  108,   94,  143,  153,
 /*   540 */   158,  163,  152,  157,  118,  120,  112,  114,  110,  116,
 /*   550 */    96,  122,  124,  126,  128,  130,  132,  134,  136,  138,
 /*   560 */   140,  847,   83,  142,  321,  641,  372,   31,  663,  282,
 /*   570 */    75,  242,  308,  689,  231,  246,  167,  334,  169,  170,
 /*   580 */   269,  108,   94,  143,  153,  158,  163,  152,  157,  118,
 /*   590 */   120,  112,  114,  110,  116,  324,  122,  124,  126,  128,
 /*   600 */   130,  132,  134,  136,  138,  140,  246,  328,  142,  328,
 /*   610 */   225,  434,   24,   39,  433,  210,  167,  211,  169,  170,
 /*   620 */   167,  331,  169,  170,  583,  435,  108,  161,  143,  153,
 /*   630 */   158,  163,  152,  157,  118,  120,  112,  114,  110,  116,
 /*   640 */   248,  122,  124,  126,  128,  130,  132,  134,  136,  138,
 /*   650 */   140,   57,   58,  142,  624,  837,  323,  727,  271,  261,
 /*   660 */   167,  243,  169,  170,  313,  312,  247,  167,  798,  169,
 /*   670 */   170,  248,   94,  143,  153,  158,  163,  152,  157,  118,
 /*   680 */   120,  112,  114,  110,  116,   96,  122,  124,  126,  128,
 /*   690 */   130,  132,  134,  136,  138,  140,  279,  247,  142,  360,
 /*   700 */   358,    6,    5,  363,  346,   75,  274,   25,  257,  489,
 /*   710 */    13,  561,   33,  503,   13,  268,  267,  269,  143,  153,
 /*   720 */   158,  163,  152,  157,  118,  120,  112,  114,  110,  116,
 /*   730 */    64,  122,  124,  126,  128,  130,  132,  134,  136,  138,
 /*   740 */   140,   26,   76,   96,  400,   77,   71,  584,   96,  451,
 /*   750 */   166,  485,   29,   76,  402,   78,  167,   71,  169,  170,
 /*   760 */   295,  451,  211,   75,   30,  257,  314,  172,   75,  195,
 /*   770 */   514,  258,  292,   14,   15,  690,   77,   14,   15,  106,
 /*   780 */   195,   77,   77,  173,  191,  315,  203,   77,  344,  215,
 /*   790 */   106,  690,  327,   77,  173,  495,  338,  588,  529,  403,
 /*   800 */   179,  177,  296,  453,  251,  209,  475,  327,  175,   73,
 /*   810 */    74,  179,  177,   95,  531,  532,   35,  213,  475,  175,
 /*   820 */    73,   74,  457,   38,   95,  378,  438,  459,  258,  501,
 /*   830 */   449,  497,  841,  411,  461,  406,  653,   76,  311,  459,
 /*   840 */   387,   71,  322,   81,  323,   42,  101,  102,  103,  104,
 /*   850 */   105,  181,  185,   96,  356,  357,   96,  101,  102,  103,
 /*   860 */   104,  105,  181,  185,  195,   76,  655,  544,  328,   71,
 /*   870 */    96,  271,  431,   75,  106,  354,   75,  489,  173,  327,
 /*   880 */   298,  215,  410,  328,  428,  430,  429,  426,  427,   96,
 /*   890 */    75,  721,  195,   76,   91,  179,  177,   71,  348,  379,
 /*   900 */   349,  323,  106,  175,   73,   74,  173,  467,   95,   75,
 /*   910 */   271,  499,  445,   93,   77,  388,  446,  323,  323,  521,
 /*   920 */   195,  454,   45,  179,  177,  285,  836,   42,   41,  432,
 /*   930 */   106,  175,   73,   74,  173,  480,   95,  269,  488,   43,
 /*   940 */   486,  101,  102,  103,  104,  105,  181,  185,  800,  721,
 /*   950 */   417,  179,  177,  229,  422,  328,   96,   96,   96,  175,
 /*   960 */    73,   74,  814,   96,   95,  522,   53,  486,  479,  101,
 /*   970 */   102,  103,  104,  105,  181,  185,   75,   75,   75,   13,
 /*   980 */   107,  109,  423,   75,   55,    8,  106,  111,  496,  857,
 /*   990 */    19,   21,   23,  401,   96,  472,   56,  101,  102,  103,
 /*  1000 */   104,  105,  181,  185,  536,  240,   81,  339,  342,  863,
 /*  1010 */   546,   61,   96,   96,   75,   96,  341,  482,  113,  483,
 /*  1020 */    95,   96,  525,  417,  456,  542,   13,   96,   96,  523,
 /*  1030 */   417,  549,   75,   75,  552,   75,  115,  117,  472,  119,
 /*  1040 */    96,   75,   14,   15,   81,  121,   96,   75,   75,   77,
 /*  1050 */   417,  123,  125,  101,  102,  103,   60,  519,  466,   96,
 /*  1060 */    75,  498,  417,  240,  127,  417,   75,   64,  500,   62,
 /*  1070 */   129,   96,   63,  690,   96,  504,  508,  452,   68,   75,
 /*  1080 */   417,  494,   96,  131,   96,   96,   81,   96,  502,   14,
 /*  1090 */    15,   75,   96,   96,   75,  133,  555,   70,  135,   96,
 /*  1100 */   506,  512,   75,  510,   75,   75,  137,   75,  139,  141,
 /*  1110 */    96,  149,   75,   75,   81,   96,  151,  160,  516,   75,
 /*  1120 */    96,   96,   96,  162,  598,   80,  599,   96,   96,   82,
 /*  1130 */    75,  240,  221,   84,  174,   75,   96,   96,   96,  176,
 /*  1140 */    75,   75,   75,   96,  178,  180,  192,   75,   75,  518,
 /*  1150 */    96,  194,  204,   96,   79,  286,   75,   75,   75,  237,
 /*  1160 */   206,  208,  220,   75,   96,   96,   96,  236,   85,  235,
 /*  1170 */    75,   96,   87,   75,  241,   75,  867,  273,  215,  283,
 /*  1180 */    86,   77,   90,   97,   75,   75,   75,   88,  382,  470,
 /*  1190 */   474,   75,   89,   98,   99,  487,  100,  140,  156,  214,
 /*  1200 */   667,  668,  669,  182,  205,  188,  190,  189,  196,  199,
 /*  1210 */   198,  201,  215,  200,  202,  216,  217,  224,  222,  228,
 /*  1220 */   227,  229,  230,  226,  234,  238,  211,  245,  233,  253,
 /*  1230 */   250,  252,  255,  272,  260,  263,  265,  256,  264,  266,
 /*  1240 */   270,  278,  287,  280,  297,  281,  300,  320,  303,  302,
 /*  1250 */   305,  307,  304,  325,  333,  329,  310,  317,  326,  351,
 /*  1260 */   355,  370,  359,  330,  319,  340,  343,  368,  371,  361,
 /*  1270 */   374,  377,  385,  335,  375,  373,  396,  386,  380,  389,
 /*  1280 */   390,   54,  366,  391,  404,  392,  407,  405,  409,  408,
 /*  1290 */   412,  413,  418,  416,  829,  414,  424,  425,  415,  834,
 /*  1300 */   420,  439,  835,  421,  436,  440,  441,  442,  443,  444,
 /*  1310 */   447,  805,  450,  806,  455,  458,  828,  460,  728,  464,
 /*  1320 */   729,  843,  453,  465,  468,  471,  463,  845,  476,  469,
 /*  1330 */   481,  478,  473,  477,  484,  846,  493,  491,  848,  492,
 /*  1340 */   660,  662,  813,  855,  505,  507,  720,  509,  511,  723,
 /*  1350 */   513,  726,  515,  815,  524,  526,  527,  520,  517,  816,
 /*  1360 */   817,  818,  819,  534,  535,  820,  856,  539,  858,  540,
 /*  1370 */   545,  538,  543,  859,  862,  548,  551,  864,  553,  550,
 /*  1380 */   537,  557,  541,  547,  865,  556,  866,  560,  559,  547,
 /*  1390 */   562,








};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */    25,   30,   27,   72,   73,   74,   75,   36,   77,   78,
 /*    10 */    79,   80,   81,   82,   83,   84,   85,   86,   10,   44,
 /*    20 */    76,   77,   78,   79,   80,   81,   82,   83,   84,   85,
 /*    30 */    86,   81,   82,   83,   84,   85,   86,   62,   63,   64,
 /*    40 */    65,   66,   67,   68,   69,   70,   71,   72,   73,   74,
 /*    50 */    75,   23,   77,   78,   79,   80,   81,   82,   83,   84,
 /*    60 */    85,   86,   10,   60,   26,   90,   77,   78,   79,   80,
 /*    70 */    81,   82,   83,   84,   85,   86,   92,   27,  148,   95,
 /*    80 */    96,   97,   44,  142,  143,  144,   48,   23,  147,   25,
 /*    90 */   150,  107,   18,   90,   24,  155,  149,   94,  158,  159,
 /*   100 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   110 */    72,   73,   74,   75,  150,   77,   78,   79,   80,   81,
 /*   120 */    82,   83,   84,   85,   86,   51,    0,   44,  177,  178,
 /*   130 */   127,  128,  129,   83,  170,  184,   10,   11,  174,  157,
 /*   140 */    90,   91,   10,  115,   22,   62,   63,   64,   65,   66,


 /*   150 */    67,   68,   69,   70,   71,   72,   73,   74,   75,   27,
 /*   160 */    77,   78,   79,   80,   81,   82,   83,   84,   85,   86,
 /*   170 */    10,  189,   44,  209,  210,   27,  102,  103,  104,  109,
 /*   180 */    45,  111,  112,  201,  202,   10,   11,  113,  206,  157,
 /*   190 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   200 */    72,   73,   74,   75,   94,   77,   78,   79,   80,   81,
 /*   210 */    82,   83,   84,   85,   86,   19,  106,  134,   96,   64,
 /*   220 */    18,  189,   90,   91,   28,  150,   83,   84,   85,   86,
 /*   230 */    14,   15,   16,  158,  159,   39,  101,   41,   90,   91,
 /*   240 */    92,  163,   27,   95,   96,   97,   44,   92,   93,   94,
 /*   250 */    95,   96,   97,   98,   99,  107,  181,  182,   25,  137,
 /*   260 */    27,  106,   64,  135,   62,   63,   64,   65,   66,   67,
 /*   270 */    68,   69,   70,   71,   72,   73,   74,   75,  200,   77,
 /*   280 */    78,   79,   80,   81,   82,   83,   84,   85,   86,   27,
 /*   290 */    24,   44,   94,   95,   96,   97,   98,   99,   24,  217,
 /*   300 */    26,  219,  220,  163,  106,   90,   91,  186,  187,   62,
 /*   310 */    63,   64,   65,   66,   67,   68,   69,   70,   71,   72,
 /*   320 */    73,   74,   75,   90,   77,   78,   79,   80,   81,   82,
 /*   330 */    83,   84,   85,   86,  217,  218,  219,  220,   24,  150,
 /*   340 */   200,  150,   19,   81,   82,   24,  110,  165,  166,  167,
 /*   350 */   114,   28,   90,   91,   24,  144,  150,  217,  147,  219,
 /*   360 */   220,   27,   39,  101,   41,   44,   92,   64,   23,   95,
 /*   370 */    96,   97,   27,   10,   51,  109,  170,  111,  112,  188,
 /*   380 */   174,  107,  135,   62,   63,   64,   65,   66,   67,   68,
 /*   390 */    69,   70,   71,   72,   73,   74,   75,   94,   77,   78,
 /*   400 */    79,   80,   81,   82,   83,   84,   85,   86,   24,  227,
 /*   410 */   165,  166,  167,  150,  150,   27,  160,  149,  212,  163,
 /*   420 */   164,   44,   10,  109,   90,  111,  112,   10,   44,  238,
 /*   430 */   224,  201,  202,  170,  170,   90,   91,  174,  174,  109,
 /*   440 */    23,  111,  112,   66,   67,  150,   62,   63,   64,   65,

 /*   450 */    66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
 /*   460 */   150,   77,   78,   79,   80,   81,   82,   83,   84,   85,
 /*   470 */    86,   94,  227,   44,  149,  212,  171,   10,   90,   91,
 /*   480 */   170,  168,  169,  188,  174,  221,   12,  224,   71,   10,


 /*   490 */   177,   62,   63,   64,   65,   66,   67,   68,   69,   70,
 /*   500 */    71,   72,   73,   74,   75,  117,   77,   78,   79,   80,
 /*   510 */    81,   82,   83,   84,   85,   86,   45,   10,   44,  150,
 /*   520 */    10,   10,  217,   13,  219,  220,  102,  103,  104,  110,
 /*   530 */   101,  150,  113,  150,  224,   64,   62,   63,   64,   65,
 /*   540 */    66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
 /*   550 */   150,   77,   78,   79,   80,   81,   82,   83,   84,   85,
 /*   560 */    86,   10,  192,   44,  183,   24,  183,   26,   10,  199,
 /*   570 */   170,   26,  101,   24,  174,   26,  109,  106,  111,  112,
 /*   580 */    26,   62,   63,   64,   65,   66,   67,   68,   69,   70,
 /*   590 */    71,   72,   73,   74,   75,  226,   77,   78,   79,   80,
 /*   600 */    81,   82,   83,   84,   85,   86,   26,  226,   44,  226,
 /*   610 */   210,   29,  149,  169,   32,   24,  109,   26,  111,  112,
 /*   620 */   109,  177,  111,  112,   10,   43,   62,   63,   64,   65,

 /*   630 */    66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
 /*   640 */    91,   77,   78,   79,   80,   81,   82,   83,   84,   85,
 /*   650 */    86,   14,   15,   44,   24,  101,   26,   10,  150,  163,
 /*   660 */   109,  116,  111,  112,   93,   94,  117,  109,   18,  111,
 /*   670 */   112,   91,   63,   64,   65,   66,   67,   68,   69,   70,
 /*   680 */    71,   72,   73,   74,   75,  150,   77,   78,   79,   80,
 /*   690 */    81,   82,   83,   84,   85,   86,  200,  117,   44,   81,
 /*   700 */    82,  145,  146,  150,   23,  170,   23,  151,   27,  174,
 /*   710 */    27,  158,  159,  157,   27,   24,  208,   26,   64,   65,
 /*   720 */    66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
 /*   730 */   100,   77,   78,   79,   80,   81,   82,   83,   84,   85,
 /*   740 */    86,  152,   23,  150,  157,  189,   27,   10,  150,  157,
 /*   750 */   157,  216,  156,   23,  153,  157,  109,   27,  111,  112,
 /*   760 */    24,  157,   26,  170,   24,   27,   33,  174,  170,   50,
 /*   770 */   214,   90,  174,   90,   91,  101,  189,   90,   91,   60,
 /*   780 */    50,  189,  189,   64,  134,   52,  136,  189,  162,  115,
 /*   790 */    60,   25,  150,  189,   64,   21,  170,   10,  150,   21,
 /*   800 */    81,   82,   83,   62,  117,  212,  214,  150,   89,   90,
 /*   810 */    91,   81,   82,   94,  166,  167,  161,  224,  214,   89,
 /*   820 */    90,   91,  230,  150,   94,  183,  225,  235,   90,   55,
 /*   830 */   229,   57,   12,   55,  230,   57,   10,   23,  105,  235,
 /*   840 */   183,   27,   24,  113,   26,  101,  127,  128,  129,  130,
 /*   850 */   131,  132,  133,  150,  127,  128,  150,  127,  128,  129,
 /*   860 */   130,  131,  132,  133,   50,   23,  125,  129,  226,   27,
 /*   870 */   150,  150,   47,  170,   60,  227,  170,  174,   64,  150,
 /*   880 */   174,  115,  157,  226,  102,  103,  104,   53,   54,  150,
 /*   890 */   170,   10,   50,   23,  174,   81,   82,   27,   24,   24,
 /*   900 */    26,   26,   60,   89,   90,   91,   64,   26,   94,  170,
 /*   910 */   150,  137,  183,  174,  189,   24,   24,   26,   26,  216,
 /*   920 */    50,  186,  187,   81,   82,   83,  101,  101,  171,  208,
 /*   930 */    60,   89,   90,   91,   64,   24,   94,   26,   24,   34,
 /*   940 */    26,  127,  128,  129,  130,  131,  132,  133,  134,   10,
 /*   950 */   150,   81,   82,   27,  134,  226,  150,  150,  150,   89,
 /*   960 */    90,   91,   10,  150,   94,   24,  171,   26,  208,  127,



 /*   970 */   128,  129,  130,  131,  132,  133,  170,  170,  170,   27,
 /*   980 */   174,  174,  174,  170,  180,   12,   60,  174,  188,   10,










 /*   990 */    17,   18,   19,   20,  150,  150,   42,  127,  128,  129,
 /*  1000 */   130,  131,  132,  133,   31,  124,  113,   81,   82,   10,
 /*  1010 */    37,  172,  150,  150,  170,  150,   90,  157,  174,  126,
 /*  1020 */    94,  150,   49,  150,   51,   46,   27,  150,  150,   56,
 /*  1030 */   150,   58,  170,  170,   61,  170,  174,  174,  150,  174,
 /*  1040 */   150,  170,   90,   91,  113,  174,  150,  170,  170,  189,
 /*  1050 */   150,  174,  174,  127,  128,  129,   46,  126,  213,  150,
 /*  1060 */   170,  188,  150,  124,  174,  150,  170,  100,  188,  171,
 /*  1070 */   174,  150,  173,   10,  150,  102,  103,  104,  171,  170,
 /*  1080 */   150,  108,  150,  174,  150,  150,  113,  150,  188,   90,
 /*  1090 */    91,  170,  150,  150,  170,  174,   59,   23,  174,  150,
 /*  1100 */   188,  213,  170,  188,  170,  170,  174,  170,  174,  174,
 /*  1110 */   150,  174,  170,  170,  113,  150,  174,  174,  188,  170,
 /*  1120 */   150,  150,  150,  174,  115,  189,  115,  150,  150,  191,
 /*  1130 */   170,  124,  119,  193,  174,  170,  150,  150,  150,  174,
 /*  1140 */   170,  170,  170,  150,  174,  174,  174,  170,  170,  157,
 /*  1150 */   150,  174,  174,  150,  190,  150,  170,  170,  170,  121,
 /*  1160 */   174,  174,  174,  170,  150,  150,  150,  174,  194,  122,
 /*  1170 */   170,  150,  196,  170,  174,  170,  139,  174,  115,  174,
 /*  1180 */   195,  189,  123,  115,  170,  170,  170,  197,  174,  174,
 /*  1190 */   174,  170,  198,  150,  115,  174,  150,   86,   94,  150,
 /*  1200 */   113,  113,  113,   23,  134,  222,   18,  223,   23,  187,
 /*  1210 */    24,  150,  115,   26,   24,  150,  154,   26,  120,   99,
 /*  1220 */   172,   27,  162,  211,  172,  120,   26,  203,  211,  117,
 /*  1230 */   150,  150,  150,  101,  150,  204,  118,  154,  205,   23,
 /*  1240 */   150,   24,  115,  204,   24,  205,  171,   23,  175,  150,
 /*  1250 */   178,  150,  176,  211,  162,  211,  179,  179,  172,   24,
 /*  1260 */   228,   46,  228,  172,  179,  170,  170,  150,   23,  163,
 /*  1270 */    24,   23,   46,  180,  171,  173,  182,   23,  171,   98,
 /*  1280 */   150,  106,  182,  175,  150,  176,  150,  154,   25,  154,
 /*  1290 */   150,  154,  154,  101,   12,  231,   40,   38,  232,  101,
 /*  1300 */   233,  137,  101,  234,   47,  150,  154,  101,  150,   23,
 /*  1310 */   171,   10,   12,  137,  185,   18,   10,   10,  125,  150,
 /*  1320 */   125,   18,   62,  105,  150,  194,  185,   10,  125,   71,
 /*  1330 */   215,   23,   71,  150,   23,   10,  194,  116,   10,  150,
 /*  1340 */    10,   10,   10,   10,  116,  194,   10,  185,  105,   10,
 /*  1350 */   194,   10,  125,   10,  150,  150,  154,   23,  215,   10,
 /*  1360 */    10,   10,   10,  150,   24,   10,   10,   25,   10,  150,
 /*  1370 */    35,  163,  163,   10,   10,  150,  154,   10,   21,  150,
 /*  1380 */   236,  150,  237,  236,   10,  138,   10,  239,  139,  240,
 /*  1390 */   140,
};
#define YY_SHIFT_USE_DFLT (-70)
static const short yy_shift_ofst[] = {
 /*     0 */   175,  126,  -70,  -70,  973,    8,   52,  -70,  216,  510,
 /*    10 */   160,  132,  363,  -70,  -70,  -70,  -70,  -70,  -70,  510,
 /*    20 */   412,  510,  479,  510,  614,   64,  737,  215,  541,  740,
 /*    30 */   787,  148,  -70,  334,  -70,  155,  -70,  215,  198,  -70,
 /*    40 */   744,  -70,  905,  323,  -70,  -70,  -70,  -70,  -70,  -70,
 /*    50 */   -70,  110,  744,  -70,  954,  -70,  637,  -70,  -70, 1010,
 /*    60 */   -29,  744,  967,  -70,  -70,  -70,  -70,  744,  -70, 1074,
 /*    70 */   870,   28,  719, 1009, 1011,  -70,  730,  -70,   70, 1001,
 /*    80 */   -70,  236,  -70,  545, 1007, 1038, 1047, 1013, 1059,  -70,
 /*    90 */   870,   38,  870,  519,  870,  -70, 1068,  215, 1079,  215,
 /*   100 */   -70,  -70,  -70,  -70,  -70,  -70,  -70,  654,  870,  609,
 /*   110 */   870,  -11,  870,  -11,  870,  -11,  870,  -11,  870,  -69,
 /*   120 */   870,  -69,  870,  -50,  870,  -50,  870,  -50,  870,  -50,
 /*   130 */   870,  143,  870,  143,  870, 1111,  870, 1111,  870, 1111,
 /*   140 */   870,  -70,  -70,  377,  -70,  -70,  -70,  -70,  870,  -56,
 /*   150 */   870,  -11,  -70,  303,  -70, 1104,  -70,  -70,  -70,  870,
 /*   160 */   564,  870,  -69,  -70,  345,  730,  266,  419, 1087, 1088,
 /*   170 */  1089,  -70,  519,  870,  654,  870,  -70,  870,  -70,  870,
 /*   180 */   -70, 1180, 1001,  314,  -70,  814,   83, 1070,  650, 1188,
 /*   190 */   -70,  870,  128,  870,  519, 1185,  196, 1186,  -70, 1187,
 /*   200 */   215, 1190,  -70,  870,  202,  870,  247,  870,  519,  591,
 /*   210 */   -70,  870,  -70,  -70, 1097,  215,  -70,  -70,  -70,  870,
 /*   220 */   519, 1098,  870, 1191,  870, 1120,  -29,  -70, 1194,  -70,
 /*   230 */   -70,  519, 1120,  -29,  -70,  870,  519, 1105,  870, 1200,
 /*   240 */   870,  519,  -70,  -70,  580,  -70,  -70,  -70,  388,  -70,
 /*   250 */   687,  -70, 1112,  -70,  683, 1097,  233,  -70,  -70,  215,
 /*   260 */   -70,  -70, 1132, 1118,  -70, 1216,  215,  691,  -70,  215,
 /*   270 */   -70,  -70,  870,  519, 1001,  330,  549, 1217,  233, 1132,
 /*   280 */  1118,  -70,  842,  -25,  -70,  -70, 1127,   50,  -70,  -70,
 /*   290 */   -70,  -70,  321,  -70,  736,  -70, 1220,  -70,  384,  744,
 /*   300 */   -70,  215, 1224,  -70,  135,  -70,  215,  -70,  424,  733,
 /*   310 */   -70,  571,  -70,  -70,  -70,  -70,  733,  -70,  733,  -70,
 /*   320 */   215,  818,  -70,  215, 1120,  -29,  -70,  -70, 1120,  -29,
 /*   330 */   -70,  -70, 1194,  -70,  954,  -70,  -70,  926,  -70,    3,
 /*   340 */   -70,  -70,    3,  -70,  -70,  681,  618,  874,  -70,  618,
 /*   350 */  1235,  -70,  -70,  -70,  727,  -70,  -70,  -70,  727,  -70,
 /*   360 */   -70,  -70,  -70,  -70,  274,  -16,  -70,  215,  -70, 1215,
 /*   370 */  1245,  215,  630, 1246,  744,  -70, 1248,  215,  875,  744,
 /*   380 */   -70,  870,  429,  -70, 1226, 1254,  215,  891, 1181,  215,
 /*   390 */  1224,  -70,  471, 1175,  -70,  -70,  -70,  -70,  -70, 1001,
 /*   400 */   467,  122,  778,  215, 1097,  -70,  215,  766, 1263, 1001,
 /*   410 */   507,  215, 1097,  582,  782, 1192,  215, 1097,  -70, 1256,
 /*   420 */   820, 1282,  870,  474, 1259,  834,  -70,  -70, 1198, 1201,
 /*   430 */   825,  215,  554,  -70,  -70, 1257,  -70,  -70, 1164,  215,
 /*   440 */   674, 1206,  215, 1286,  215,  892,  826, 1301, 1176, 1300,
 /*   450 */    74,  511,  741,  323,  -70, 1193, 1195, 1297, 1306, 1307,
 /*   460 */    74, 1303, 1260,  215, 1218,  215,  881,  215, 1258,  870,
 /*   470 */   519, 1317, 1261,  870,  519, 1203,  215, 1308,  215,  911,
 /*   480 */   -70,  893,  551, 1311,  870,  914,  870,  519, 1325,  519,
 /*   490 */  1221,  215,  939, 1328,  774,  215, 1330,  215, 1331,  215,
 /*   500 */  1332,  215, 1333,  558, 1228,  215,  939, 1336, 1260,  215,
 /*   510 */  1243,  215,  881, 1339, 1227,  215, 1308,  931,  647, 1334,
 /*   520 */   870,  941, 1341,  952, 1343,  215, 1097,  417,  262, 1349,
 /*   530 */  1350, 1351, 1352,  215, 1340, 1355, 1335,  334, 1342,  215,
 /*   540 */   979, 1356,  738, 1358, 1363,  -70, 1335,  215, 1364,  999,
 /*   550 */  1063, 1367, 1357,  215, 1037, 1247,  215, 1374, 1249, 1250,
 /*   560 */   215, 1376,  -70,  -70,  -70,

};
#define YY_REDUCE_USE_DFLT (-71)
static const short yy_reduce_ofst[] = {
 /*     0 */   -59,  211,  -71,  -71,  556,  -71,  -71,  -71,  -70,  -53,
 /*    10 */   -71,  189,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  268,
 /*    20 */   -71,  325,  -71,  463,  -71,  589,  -71,  -60,  596,  -71,
 /*    30 */   -71,   75,  -71,  256,  655,  313,  -71,  673,  444,  -71,
 /*    40 */   757,  -71,  -71,  121,  -71,  -71,  -71,  -71,  -71,  -71,
 /*    50 */   -71,  -71,  795,  -71,  804,  -71,  -71,  -71,  -71,  -71,
 /*    60 */   839,  898,  899,  -71,  -71,  -71,  -71,  907,  -71,  -71,
 /*    70 */   706,  -71,  206,  -71,  -71,  -71,  598,  -71,  964,  936,
 /*    80 */   -71,  938,  370,  940,  974,  985,  976,  990,  994,  -71,
 /*    90 */   720,   82,  739,   82,  806,  -71,  -71, 1043,  -71, 1046,
 /*   100 */   -71,  -71,  -71,  -71,  -71,  -71,  -71,   82,  807,   82,
 /*   110 */   813,   82,  844,   82,  862,   82,  863,   82,  865,   82,
 /*   120 */   871,   82,  877,   82,  878,   82,  890,   82,  896,   82,
 /*   130 */   909,   82,  921,   82,  924,   82,  932,   82,  934,   82,
 /*   140 */   935,   82,  -71,  -71,  -71,  -71,  -71,  -71,  937,  117,
 /*   150 */   942,   82,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  943,
 /*   160 */    82,  949,   82,  -71, 1049,  593,  964,  -71,  -71,  -71,
 /*   170 */   -71,  -71,   82,  960,   82,  965,   82,  970,   82,  971,
 /*   180 */    82,  -71,   32,  964,  -71,  264,   82,  983,  984,  -71,
 /*   190 */   -71,  972,   82,  977,   82,  -71, 1022,  -71,  -71,  -71,
 /*   200 */  1061,  -71,  -71,  978,   82,  986,   82,  987,   82,  -71,
 /*   210 */   -71,  310,  -71,  -71, 1062, 1065,  -71,  -71,  -71,  988,
 /*   220 */    82,  -71,  -36,  -71,  400, 1012, 1048,  -71, 1060,  -71,
 /*   230 */   -71,   82, 1017, 1052,  -71,  993,   82,  -71,  263,  -71,
 /*   240 */  1000,   82,  -71,  230, 1024,  -71,  -71,  -71, 1080,  -71,
 /*   250 */  1081,  -71,  -71,  -71, 1082, 1083,   78,  -71,  -71, 1084,
 /*   260 */   -71,  -71, 1031, 1033,  -71,  -71,  508,  -71,  -71, 1090,
 /*   270 */   -71,  -71, 1003,   82,  -18,  964, 1024,  -71,  496, 1039,
 /*   280 */  1040,  -71, 1005,  140,  -71,  -71,  -71, 1043,  -71,  -71,
 /*   290 */   -71,  -71,   82,  -71,  -71,  -71,  -71,  -71,   82, 1075,
 /*   300 */   -71, 1099, 1073, 1076, 1072,  -71, 1101,  -71,  -71, 1077,
 /*   310 */   -71,  -71,  -71,  -71,  -71,  -71, 1078,  -71, 1085,  -71,
 /*   320 */   381,  -71,  -71,  369, 1042, 1086,  -71,  -71, 1044, 1091,
 /*   330 */   -71,  -71, 1092,  -71, 1093,  -71,  -71,  626,  -71, 1095,
 /*   340 */   -71,  -71, 1096,  -71,  -71, 1106,  182,  -71,  -71,  245,
 /*   350 */   -71,  -71,  -71,  -71, 1032,  -71,  -71,  -71, 1034,  -71,
 /*   360 */   -71,  -71,  -71,  -71, 1094, 1100,  -71, 1117,  -71,  -71,
 /*   370 */   -71,  383, 1102,  -71, 1103,  -71,  -71,  642,  -71, 1107,
 /*   380 */   -71, 1014,  305,  -71,  -71,  -71,  657,  -71,  -71, 1130,
 /*   390 */  1108, 1109,  -49,  -71,  -71,  -71,  -71,  -71,  -71,  587,
 /*   400 */   964,  601,  -71, 1134, 1133,  -71, 1136, 1135,  -71,  725,
 /*   410 */   964, 1140, 1137, 1064, 1066,  -71,  295, 1138,  -71, 1067,
 /*   420 */  1069,  -71,  808,   82,  -71,  -71,  -71,  -71,  -71,  -71,
 /*   430 */   -71,  721,  -71,  -71,  -71,  -71,  -71,  -71,  -71, 1155,
 /*   440 */  1152,  -71, 1158,  -71,  729,  -71, 1139,  -71,  -71,  -71,
 /*   450 */   592,  964, 1129,  735,  -71,  -71,  -71,  -71,  -71,  -71,
 /*   460 */   604,  -71, 1141, 1169,  -71,  845, 1131, 1174,  -71, 1015,
 /*   470 */    82,  -71,  -71, 1016,   82,  -71, 1183, 1115,  760,  -71,
 /*   480 */   -71,  860,  964,  -71,  535,  -71, 1021,   82,  -71,   82,
 /*   490 */   -71, 1189, 1142,  -71,  -71,  800,  -71,  873,  -71,  880,
 /*   500 */   -71,  900,  -71,  964,  -71,  912, 1151,  -71, 1162,  915,
 /*   510 */   -71,  888, 1156,  -71,  -71,  930, 1143,  992,  964,  -71,
 /*   520 */   703,  -71,  -71, 1204,  -71, 1205, 1202,  -71,  648,  -71,
 /*   530 */   -71,  -71,  -71, 1213,  -71,  -71, 1144, 1208,  -71, 1219,
 /*   540 */  1145,  -71, 1209,  -71,  -71,  -71, 1147, 1225,  -71, 1229,
 /*   550 */  1222,  -71,  -71,  191,  -71,  -71, 1231,  -71,  -71, 1148,
 /*   560 */   553,  -71,  -71,  -71,  -71,

};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */   571,  571,  566,  569,  870,  870,  870,  570,  577,  870,
 /*    10 */   870,  870,  870,  597,  598,  599,  578,  579,  580,  870,
 /*    20 */   870,  870,  870,  870,  870,  870,  870,  870,  870,  870,
 /*    30 */   870,  870,  590,  600,  609,  592,  608,  870,  870,  610,
 /*    40 */   653,  616,  870,  870,  654,  657,  658,  659,  852,  853,
 /*    50 */   854,  870,  653,  617,  638,  636,  870,  639,  640,  870,
 /*    60 */   709,  653,  624,  618,  625,  707,  708,  653,  619,  870,
 /*    70 */   870,  739,  804,  745,  740,  736,  870,  664,  870,  870,
 /*    80 */   665,  673,  675,  682,  721,  712,  714,  702,  716,  670,
 /*    90 */   870,  717,  870,  718,  870,  738,  870,  870,  741,  870,
 /*   100 */   742,  743,  744,  746,  747,  748,  751,  752,  870,  753,
 /*   110 */   870,  754,  870,  755,  870,  756,  870,  757,  870,  758,
 /*   120 */   870,  759,  870,  760,  870,  761,  870,  762,  870,  763,
 /*   130 */   870,  764,  870,  765,  870,  766,  870,  767,  870,  768,
 /*   140 */   870,  769,  770,  870,  771,  778,  785,  788,  870,  773,
 /*   150 */   870,  772,  775,  870,  776,  870,  779,  777,  784,  870,
 /*   160 */   870,  870,  786,  787,  870,  804,  870,  870,  870,  870,
 /*   170 */   870,  791,  803,  870,  780,  870,  781,  870,  782,  870,
 /*   180 */   783,  870,  870,  870,  793,  870,  870,  870,  870,  870,
 /*   190 */   794,  870,  870,  870,  795,  870,  870,  870,  850,  870,
 /*   200 */   870,  870,  851,  870,  870,  870,  870,  870,  796,  870,
 /*   210 */   789,  804,  801,  802,  690,  870,  691,  792,  774,  870,
 /*   220 */   719,  870,  870,  703,  870,  710,  709,  704,  870,  594,
 /*   230 */   711,  706,  710,  709,  705,  870,  715,  870,  804,  713,
 /*   240 */   870,  722,  674,  685,  683,  684,  693,  694,  870,  695,
 /*   250 */   870,  696,  870,  697,  870,  690,  681,  595,  596,  870,
 /*   260 */   679,  680,  699,  701,  686,  870,  870,  870,  700,  870,
 /*   270 */   734,  735,  870,  698,  685,  870,  870,  870,  681,  699,
 /*   280 */   701,  687,  870,  681,  676,  677,  870,  870,  678,  671,
 /*   290 */   672,  790,  870,  737,  870,  749,  870,  750,  870,  653,
 /*   300 */   620,  870,  808,  626,  621,  627,  870,  628,  870,  870,
 /*   310 */   629,  870,  632,  633,  634,  635,  870,  630,  870,  631,
 /*   320 */   870,  870,  809,  870,  710,  709,  810,  812,  710,  709,
 /*   330 */   811,  622,  870,  623,  638,  637,  611,  870,  612,  870,
 /*   340 */   613,  745,  870,  614,  615,  601,  827,  870,  602,  827,
 /*   350 */   870,  603,  606,  607,  870,  822,  824,  825,  870,  823,
 /*   360 */   826,  605,  604,  593,  870,  870,  643,  870,  646,  870,
 /*   370 */   870,  870,  870,  870,  653,  647,  870,  870,  870,  653,
 /*   380 */   648,  870,  653,  649,  870,  870,  870,  870,  870,  870,
 /*   390 */   808,  626,  651,  870,  650,  652,  644,  645,  591,  870,
 /*   400 */   870,  587,  870,  870,  690,  585,  870,  870,  870,  870,
 /*   410 */   870,  870,  690,  833,  870,  870,  870,  690,  692,  838,
 /*   420 */   870,  870,  870,  870,  870,  870,  839,  840,  870,  870,
 /*   430 */   870,  870,  870,  830,  831,  870,  832,  586,  870,  870,
 /*   440 */   870,  870,  870,  870,  870,  870,  870,  870,  870,  870,
 /*   450 */   870,  870,  870,  870,  656,  870,  870,  870,  870,  870,
 /*   460 */   870,  870,  655,  870,  870,  870,  870,  870,  870,  870,
 /*   470 */   724,  870,  870,  870,  725,  870,  870,  732,  870,  870,
 /*   480 */   733,  870,  870,  870,  870,  870,  870,  730,  870,  731,
 /*   490 */   870,  870,  870,  870,  870,  870,  870,  870,  870,  870,
 /*   500 */   870,  870,  870,  870,  870,  870,  870,  870,  655,  870,
 /*   510 */   870,  870,  870,  870,  870,  870,  732,  870,  870,  870,
 /*   520 */   870,  870,  870,  870,  870,  870,  690,  870,  827,  870,
 /*   530 */   870,  870,  870,  870,  870,  870,  861,  870,  870,  870,
 /*   540 */   870,  870,  870,  870,  870,  860,  861,  870,  870,  870,
 /*   550 */   870,  870,  870,  870,  870,  870,  870,  870,  870,  868,
 /*   560 */   870,  870,  869,  572,  567,

};
#define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0]))

/* The next table maps tokens into fallback tokens.  If a construct
** like the following:
** 
**      %fallback ID X Y Z.